From 5ce5b4dda4241de59490c95faa407e57d98a39b0 Mon Sep 17 00:00:00 2001 From: "Zed A. Shaw" Date: Fri, 21 Aug 2026 13:15:55 -0400 Subject: [PATCH] Commit of work up to day 11 of learnopengl.com. --- .gitignore | 13 + 01-hello-triangle/.gitignore | 10 + 01-hello-triangle/.vimrc_proj | 1 + 01-hello-triangle/KHR/khrplatform.h | 311 + 01-hello-triangle/LICENSE | 16 + 01-hello-triangle/Makefile | 27 + 01-hello-triangle/glad/glad.cpp | 1140 +++ 01-hello-triangle/glad/glad.h | 2129 +++++ 01-hello-triangle/meson.build | 76 + 01-hello-triangle/scripts/reset_build.ps1 | 7 + 01-hello-triangle/scripts/reset_build.sh | 10 + 01-hello-triangle/scripts/setup.ps1 | 4 + 01-hello-triangle/scripts/setup.sh | 7 + 01-hello-triangle/scripts/watch_build.sh | 12 + 01-hello-triangle/scripts/windows_setup.ps1 | 255 + 01-hello-triangle/src/dbc.cpp | 48 + 01-hello-triangle/src/dbc.hpp | 49 + 01-hello-triangle/src/main.cpp | 188 + 01-hello-triangle/wraps/glfw.wrap | 13 + 02-shader-class/.gitignore | 10 + 02-shader-class/.vimrc_proj | 1 + 02-shader-class/KHR/khrplatform.h | 311 + 02-shader-class/LICENSE | 16 + 02-shader-class/Makefile | 30 + 02-shader-class/glad/glad.cpp | 1140 +++ 02-shader-class/glad/glad.h | 2129 +++++ 02-shader-class/meson.build | 91 + 02-shader-class/scripts/reset_build.ps1 | 7 + 02-shader-class/scripts/reset_build.sh | 10 + 02-shader-class/scripts/setup.ps1 | 4 + 02-shader-class/scripts/setup.sh | 7 + 02-shader-class/scripts/watch_build.sh | 12 + 02-shader-class/scripts/windows_setup.ps1 | 255 + 02-shader-class/shaders/3.3.shader.fs | 8 + 02-shader-class/shaders/3.3.shader.vs | 11 + 02-shader-class/src/dbc.cpp | 47 + 02-shader-class/src/dbc.hpp | 46 + 02-shader-class/src/main.cpp | 133 + 02-shader-class/src/shader.cpp | 101 + 02-shader-class/src/shader.hpp | 20 + 02-shader-class/tests/bad_shader.vs | 10 + 02-shader-class/tests/main.cpp | 38 + 02-shader-class/tests/meson.build | 4 + 02-shader-class/tests/shader_tests.cpp | 33 + 02-shader-class/wraps/fmt.wrap | 13 + 02-shader-class/wraps/fuc2.wrap | 9 + 02-shader-class/wraps/glfw.wrap | 13 + 03-textures/.gitignore | 10 + 03-textures/.vimrc_proj | 1 + 03-textures/KHR/khrplatform.h | 311 + 03-textures/LICENSE | 16 + 03-textures/Makefile | 30 + 03-textures/glad/glad.cpp | 1140 +++ 03-textures/glad/glad.h | 2129 +++++ 03-textures/meson.build | 92 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes 03-textures/resources/textures/container.jpg | Bin 0 -> 184939 bytes 03-textures/scripts/reset_build.ps1 | 7 + 03-textures/scripts/reset_build.sh | 10 + 03-textures/scripts/setup.ps1 | 4 + 03-textures/scripts/setup.sh | 7 + 03-textures/scripts/watch_build.sh | 12 + 03-textures/scripts/windows_setup.ps1 | 255 + 03-textures/shaders/3.3.shader.fs | 8 + 03-textures/shaders/3.3.shader.vs | 11 + 03-textures/shaders/4.2.texture.fs | 14 + 03-textures/shaders/4.2.texture.vs | 14 + 03-textures/src/dbc.cpp | 47 + 03-textures/src/dbc.hpp | 46 + 03-textures/src/main.cpp | 192 + 03-textures/src/shader.cpp | 101 + 03-textures/src/shader.hpp | 20 + 03-textures/src/stb_image.cpp | 2 + 03-textures/src/stb_image.h | 7988 +++++++++++++++++ 03-textures/tests/bad_shader.vs | 10 + 03-textures/tests/main.cpp | 38 + 03-textures/tests/meson.build | 4 + 03-textures/tests/shader_tests.cpp | 33 + 03-textures/wraps/fmt.wrap | 13 + 03-textures/wraps/fuc2.wrap | 9 + 03-textures/wraps/glfw.wrap | 13 + 04-transformations/.gitignore | 10 + 04-transformations/.vimrc_proj | 1 + 04-transformations/KHR/khrplatform.h | 311 + 04-transformations/LICENSE | 16 + 04-transformations/Makefile | 30 + 04-transformations/glad/glad.cpp | 1140 +++ 04-transformations/glad/glad.h | 2129 +++++ 04-transformations/meson.build | 94 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes .../resources/textures/container.jpg | Bin 0 -> 184939 bytes 04-transformations/scripts/reset_build.ps1 | 7 + 04-transformations/scripts/reset_build.sh | 10 + 04-transformations/scripts/setup.ps1 | 4 + 04-transformations/scripts/setup.sh | 7 + 04-transformations/scripts/watch_build.sh | 12 + 04-transformations/scripts/windows_setup.ps1 | 255 + 04-transformations/shaders/3.3.shader.fs | 8 + 04-transformations/shaders/3.3.shader.vs | 11 + 04-transformations/shaders/4.2.texture.fs | 13 + 04-transformations/shaders/4.2.texture.vs | 16 + 04-transformations/src/dbc.cpp | 47 + 04-transformations/src/dbc.hpp | 46 + 04-transformations/src/main.cpp | 264 + 04-transformations/src/shader.cpp | 101 + 04-transformations/src/shader.hpp | 20 + 04-transformations/src/stb_image.cpp | 2 + 04-transformations/src/stb_image.h | 7988 +++++++++++++++++ 04-transformations/tests/bad_shader.vs | 10 + 04-transformations/tests/main.cpp | 38 + 04-transformations/tests/meson.build | 4 + 04-transformations/tests/shader_tests.cpp | 33 + 04-transformations/wraps/box2d.wrap | 13 + 04-transformations/wraps/fmt.wrap | 13 + 04-transformations/wraps/fuc2.wrap | 9 + 04-transformations/wraps/glfw.wrap | 13 + 04-transformations/wraps/glm.wrap | 13 + 05-coordinate_systems/.gitignore | 10 + 05-coordinate_systems/.vimrc_proj | 1 + 05-coordinate_systems/KHR/khrplatform.h | 311 + 05-coordinate_systems/LICENSE | 16 + 05-coordinate_systems/Makefile | 30 + 05-coordinate_systems/glad/glad.cpp | 1140 +++ 05-coordinate_systems/glad/glad.h | 2129 +++++ 05-coordinate_systems/meson.build | 95 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes .../resources/textures/container.jpg | Bin 0 -> 184939 bytes 05-coordinate_systems/scripts/reset_build.ps1 | 7 + 05-coordinate_systems/scripts/reset_build.sh | 10 + 05-coordinate_systems/scripts/setup.ps1 | 4 + 05-coordinate_systems/scripts/setup.sh | 7 + 05-coordinate_systems/scripts/watch_build.sh | 12 + .../scripts/windows_setup.ps1 | 255 + 05-coordinate_systems/shaders/3.3.shader.fs | 8 + 05-coordinate_systems/shaders/3.3.shader.vs | 11 + 05-coordinate_systems/shaders/4.2.texture.fs | 12 + 05-coordinate_systems/shaders/4.2.texture.vs | 15 + 05-coordinate_systems/src/data.hpp | 47 + 05-coordinate_systems/src/dbc.cpp | 47 + 05-coordinate_systems/src/dbc.hpp | 46 + 05-coordinate_systems/src/main.cpp | 214 + 05-coordinate_systems/src/physics.cpp | 49 + 05-coordinate_systems/src/physics.hpp | 13 + 05-coordinate_systems/src/shader.cpp | 109 + 05-coordinate_systems/src/shader.hpp | 22 + 05-coordinate_systems/src/stb_image.cpp | 2 + 05-coordinate_systems/src/stb_image.h | 7988 +++++++++++++++++ 05-coordinate_systems/tests/bad_shader.vs | 10 + 05-coordinate_systems/tests/main.cpp | 38 + 05-coordinate_systems/tests/meson.build | 4 + 05-coordinate_systems/tests/shader_tests.cpp | 33 + 05-coordinate_systems/wraps/box2d.wrap | 13 + 05-coordinate_systems/wraps/fmt.wrap | 13 + 05-coordinate_systems/wraps/fuc2.wrap | 9 + 05-coordinate_systems/wraps/glfw.wrap | 13 + 05-coordinate_systems/wraps/glm.wrap | 13 + 06-camera/.gitignore | 10 + 06-camera/.vimrc_proj | 1 + 06-camera/KHR/khrplatform.h | 311 + 06-camera/LICENSE | 16 + 06-camera/Makefile | 30 + 06-camera/glad/glad.cpp | 1140 +++ 06-camera/glad/glad.h | 2129 +++++ 06-camera/meson.build | 95 + 06-camera/resources/textures/awesomeface.png | Bin 0 -> 59277 bytes 06-camera/resources/textures/container.jpg | Bin 0 -> 184939 bytes 06-camera/scripts/reset_build.ps1 | 7 + 06-camera/scripts/reset_build.sh | 10 + 06-camera/scripts/setup.ps1 | 4 + 06-camera/scripts/setup.sh | 7 + 06-camera/scripts/watch_build.sh | 12 + 06-camera/scripts/windows_setup.ps1 | 255 + 06-camera/shaders/3.3.shader.fs | 8 + 06-camera/shaders/3.3.shader.vs | 11 + 06-camera/shaders/4.2.texture.fs | 12 + 06-camera/shaders/4.2.texture.vs | 15 + 06-camera/src/data.hpp | 47 + 06-camera/src/dbc.cpp | 47 + 06-camera/src/dbc.hpp | 46 + 06-camera/src/main.cpp | 335 + 06-camera/src/physics.cpp | 49 + 06-camera/src/physics.hpp | 13 + 06-camera/src/shader.cpp | 109 + 06-camera/src/shader.hpp | 22 + 06-camera/src/stb_image.cpp | 2 + 06-camera/src/stb_image.h | 7988 +++++++++++++++++ 06-camera/tests/bad_shader.vs | 10 + 06-camera/tests/main.cpp | 38 + 06-camera/tests/meson.build | 4 + 06-camera/tests/shader_tests.cpp | 33 + 06-camera/wraps/box2d.wrap | 13 + 06-camera/wraps/fmt.wrap | 13 + 06-camera/wraps/fuc2.wrap | 9 + 06-camera/wraps/glfw.wrap | 13 + 06-camera/wraps/glm.wrap | 13 + 07-model-loading/.gitignore | 10 + 07-model-loading/.vimrc_proj | 1 + 07-model-loading/KHR/khrplatform.h | 311 + 07-model-loading/LICENSE | 16 + 07-model-loading/Makefile | 30 + 07-model-loading/assets/popcorn_model_a.glb | Bin 0 -> 18084 bytes 07-model-loading/glad/glad.cpp | 1140 +++ 07-model-loading/glad/glad.h | 2129 +++++ 07-model-loading/meson.build | 99 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes .../resources/textures/container.jpg | Bin 0 -> 184939 bytes .../resources/textures/popcorn.jpg | Bin 0 -> 12718 bytes 07-model-loading/scripts/reset_build.ps1 | 7 + 07-model-loading/scripts/reset_build.sh | 10 + 07-model-loading/scripts/setup.ps1 | 4 + 07-model-loading/scripts/setup.sh | 7 + 07-model-loading/scripts/watch_build.sh | 12 + 07-model-loading/scripts/windows_setup.ps1 | 255 + 07-model-loading/shaders/3.3.shader.fs | 8 + 07-model-loading/shaders/3.3.shader.vs | 11 + 07-model-loading/shaders/4.2.texture.fs | 11 + 07-model-loading/shaders/4.2.texture.vs | 15 + 07-model-loading/src/data.hpp | 47 + 07-model-loading/src/dbc.cpp | 47 + 07-model-loading/src/dbc.hpp | 46 + 07-model-loading/src/main.cpp | 307 + 07-model-loading/src/mesh.cpp | 56 + 07-model-loading/src/mesh.hpp | 42 + 07-model-loading/src/model.cpp | 169 + 07-model-loading/src/model.hpp | 40 + 07-model-loading/src/physics.cpp | 49 + 07-model-loading/src/physics.hpp | 13 + 07-model-loading/src/shader.cpp | 109 + 07-model-loading/src/shader.hpp | 22 + 07-model-loading/src/stb_image.cpp | 2 + 07-model-loading/src/stb_image.h | 7988 +++++++++++++++++ 07-model-loading/tests/bad_shader.vs | 10 + 07-model-loading/tests/main.cpp | 38 + 07-model-loading/tests/meson.build | 4 + 07-model-loading/tests/shader_tests.cpp | 33 + 07-model-loading/wraps/assimp.wrap | 9 + 07-model-loading/wraps/box2d.wrap | 13 + 07-model-loading/wraps/fmt.wrap | 13 + 07-model-loading/wraps/fuc2.wrap | 9 + 07-model-loading/wraps/glfw.wrap | 13 + 07-model-loading/wraps/glm.wrap | 13 + 08-colors-basic-light/.gitignore | 10 + 08-colors-basic-light/.vimrc_proj | 1 + 08-colors-basic-light/KHR/khrplatform.h | 311 + 08-colors-basic-light/LICENSE | 16 + 08-colors-basic-light/Makefile | 30 + .../assets/popcorn_model_a.glb | Bin 0 -> 18084 bytes 08-colors-basic-light/glad/glad.cpp | 1140 +++ 08-colors-basic-light/glad/glad.h | 2129 +++++ 08-colors-basic-light/meson.build | 100 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes .../resources/textures/container.jpg | Bin 0 -> 184939 bytes .../resources/textures/popcorn.jpg | Bin 0 -> 6006 bytes 08-colors-basic-light/scripts/reset_build.ps1 | 7 + 08-colors-basic-light/scripts/reset_build.sh | 10 + 08-colors-basic-light/scripts/setup.ps1 | 4 + 08-colors-basic-light/scripts/setup.sh | 7 + 08-colors-basic-light/scripts/watch_build.sh | 12 + .../scripts/windows_setup.ps1 | 255 + 08-colors-basic-light/shaders/08-frag.glsl | 26 + .../shaders/08-lightsource.frag.glsl | 7 + 08-colors-basic-light/shaders/08-vert.glsl | 22 + 08-colors-basic-light/shaders/3.3.shader.fs | 8 + 08-colors-basic-light/shaders/3.3.shader.vs | 11 + 08-colors-basic-light/shaders/4.2.texture.fs | 11 + 08-colors-basic-light/shaders/4.2.texture.vs | 15 + 08-colors-basic-light/src/camera.cpp | 63 + 08-colors-basic-light/src/camera.hpp | 26 + 08-colors-basic-light/src/data.hpp | 46 + 08-colors-basic-light/src/dbc.cpp | 47 + 08-colors-basic-light/src/dbc.hpp | 46 + 08-colors-basic-light/src/main.cpp | 282 + 08-colors-basic-light/src/mesh.cpp | 57 + 08-colors-basic-light/src/mesh.hpp | 42 + 08-colors-basic-light/src/model.cpp | 171 + 08-colors-basic-light/src/model.hpp | 40 + 08-colors-basic-light/src/physics.cpp | 49 + 08-colors-basic-light/src/physics.hpp | 13 + 08-colors-basic-light/src/shader.cpp | 126 + 08-colors-basic-light/src/shader.hpp | 25 + 08-colors-basic-light/src/stb_image.cpp | 2 + 08-colors-basic-light/src/stb_image.h | 7988 +++++++++++++++++ 08-colors-basic-light/tests/bad_shader.vs | 10 + 08-colors-basic-light/tests/main.cpp | 38 + 08-colors-basic-light/tests/meson.build | 4 + 08-colors-basic-light/tests/shader_tests.cpp | 33 + 08-colors-basic-light/wraps/assimp.wrap | 9 + 08-colors-basic-light/wraps/box2d.wrap | 13 + 08-colors-basic-light/wraps/fmt.wrap | 13 + 08-colors-basic-light/wraps/fuc2.wrap | 9 + 08-colors-basic-light/wraps/glfw.wrap | 13 + 08-colors-basic-light/wraps/glm.wrap | 13 + 09-basic-light-materials/.gitignore | 10 + 09-basic-light-materials/.vimrc_proj | 1 + 09-basic-light-materials/KHR/khrplatform.h | 311 + 09-basic-light-materials/LICENSE | 16 + 09-basic-light-materials/Makefile | 30 + .../assets/popcorn_model_a.glb | Bin 0 -> 18016 bytes .../assets/popcorn_model_a.mtl | 2 + .../assets/popcorn_model_a.obj | 293 + 09-basic-light-materials/glad/glad.cpp | 1140 +++ 09-basic-light-materials/glad/glad.h | 2129 +++++ 09-basic-light-materials/meson.build | 100 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes .../resources/textures/container.jpg | Bin 0 -> 184939 bytes .../resources/textures/popcorn.jpg | Bin 0 -> 6006 bytes .../scripts/reset_build.ps1 | 7 + .../scripts/reset_build.sh | 10 + 09-basic-light-materials/scripts/setup.ps1 | 4 + 09-basic-light-materials/scripts/setup.sh | 7 + .../scripts/watch_build.sh | 12 + .../scripts/windows_setup.ps1 | 255 + 09-basic-light-materials/shaders/08-frag.glsl | 32 + .../shaders/08-lightsource.frag.glsl | 7 + 09-basic-light-materials/shaders/08-vert.glsl | 17 + .../shaders/3.3.shader.fs | 8 + .../shaders/3.3.shader.vs | 11 + .../shaders/4.2.texture.fs | 11 + .../shaders/4.2.texture.vs | 15 + 09-basic-light-materials/src/camera.cpp | 63 + 09-basic-light-materials/src/camera.hpp | 26 + 09-basic-light-materials/src/data.hpp | 46 + 09-basic-light-materials/src/dbc.cpp | 47 + 09-basic-light-materials/src/dbc.hpp | 46 + 09-basic-light-materials/src/main.cpp | 319 + 09-basic-light-materials/src/mesh.cpp | 57 + 09-basic-light-materials/src/mesh.hpp | 42 + 09-basic-light-materials/src/model.cpp | 171 + 09-basic-light-materials/src/model.hpp | 40 + 09-basic-light-materials/src/physics.cpp | 49 + 09-basic-light-materials/src/physics.hpp | 13 + 09-basic-light-materials/src/shader.cpp | 126 + 09-basic-light-materials/src/shader.hpp | 25 + 09-basic-light-materials/src/stb_image.cpp | 2 + 09-basic-light-materials/src/stb_image.h | 7988 +++++++++++++++++ 09-basic-light-materials/tests/bad_shader.vs | 10 + 09-basic-light-materials/tests/main.cpp | 38 + 09-basic-light-materials/tests/meson.build | 4 + .../tests/shader_tests.cpp | 33 + 09-basic-light-materials/wraps/assimp.wrap | 9 + 09-basic-light-materials/wraps/box2d.wrap | 13 + 09-basic-light-materials/wraps/fmt.wrap | 13 + 09-basic-light-materials/wraps/fuc2.wrap | 9 + 09-basic-light-materials/wraps/glfw.wrap | 13 + 09-basic-light-materials/wraps/glm.wrap | 13 + 10-materials/.gitignore | 10 + 10-materials/.vimrc_proj | 1 + 10-materials/KHR/khrplatform.h | 311 + 10-materials/LICENSE | 16 + 10-materials/Makefile | 30 + 10-materials/assets/popcorn_model_a.glb | Bin 0 -> 18016 bytes 10-materials/glad/glad.cpp | 1140 +++ 10-materials/glad/glad.h | 2129 +++++ 10-materials/meson.build | 100 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes 10-materials/resources/textures/container.jpg | Bin 0 -> 184939 bytes 10-materials/resources/textures/popcorn.jpg | Bin 0 -> 6006 bytes 10-materials/scripts/reset_build.ps1 | 7 + 10-materials/scripts/reset_build.sh | 10 + 10-materials/scripts/setup.ps1 | 4 + 10-materials/scripts/setup.sh | 7 + 10-materials/scripts/watch_build.sh | 12 + 10-materials/scripts/windows_setup.ps1 | 255 + 10-materials/shaders/08-frag.glsl | 43 + 10-materials/shaders/08-lightsource.frag.glsl | 16 + 10-materials/shaders/08-vert.glsl | 17 + 10-materials/shaders/3.3.shader.fs | 8 + 10-materials/shaders/3.3.shader.vs | 11 + 10-materials/shaders/4.2.texture.fs | 11 + 10-materials/shaders/4.2.texture.vs | 15 + 10-materials/src/camera.cpp | 63 + 10-materials/src/camera.hpp | 27 + 10-materials/src/data.hpp | 46 + 10-materials/src/dbc.cpp | 47 + 10-materials/src/dbc.hpp | 46 + 10-materials/src/main.cpp | 334 + 10-materials/src/mesh.cpp | 57 + 10-materials/src/mesh.hpp | 42 + 10-materials/src/model.cpp | 171 + 10-materials/src/model.hpp | 40 + 10-materials/src/physics.cpp | 49 + 10-materials/src/physics.hpp | 13 + 10-materials/src/shader.cpp | 126 + 10-materials/src/shader.hpp | 53 + 10-materials/src/stb_image.cpp | 2 + 10-materials/src/stb_image.h | 7988 +++++++++++++++++ 10-materials/tests/bad_shader.vs | 10 + 10-materials/tests/main.cpp | 38 + 10-materials/tests/meson.build | 4 + 10-materials/tests/shader_tests.cpp | 33 + 10-materials/wraps/assimp.wrap | 9 + 10-materials/wraps/box2d.wrap | 13 + 10-materials/wraps/fmt.wrap | 13 + 10-materials/wraps/fuc2.wrap | 9 + 10-materials/wraps/glfw.wrap | 13 + 10-materials/wraps/glm.wrap | 13 + 11-lightmaps/.gitignore | 10 + 11-lightmaps/.vimrc_proj | 1 + 11-lightmaps/KHR/khrplatform.h | 311 + 11-lightmaps/LICENSE | 16 + 11-lightmaps/Makefile | 30 + 11-lightmaps/assets/popcorn_model_a.glb | Bin 0 -> 18016 bytes 11-lightmaps/glad/glad.cpp | 1140 +++ 11-lightmaps/glad/glad.h | 2129 +++++ 11-lightmaps/meson.build | 100 + .../resources/textures/awesomeface.png | Bin 0 -> 59277 bytes 11-lightmaps/resources/textures/container.jpg | Bin 0 -> 184939 bytes 11-lightmaps/resources/textures/popcorn.jpg | Bin 0 -> 6006 bytes 11-lightmaps/scripts/reset_build.ps1 | 7 + 11-lightmaps/scripts/reset_build.sh | 10 + 11-lightmaps/scripts/setup.ps1 | 4 + 11-lightmaps/scripts/setup.sh | 7 + 11-lightmaps/scripts/watch_build.sh | 12 + 11-lightmaps/scripts/windows_setup.ps1 | 255 + 11-lightmaps/shaders/08-frag.glsl | 43 + 11-lightmaps/shaders/08-lightsource.frag.glsl | 16 + 11-lightmaps/shaders/08-vert.glsl | 17 + 11-lightmaps/shaders/3.3.shader.fs | 8 + 11-lightmaps/shaders/3.3.shader.vs | 11 + 11-lightmaps/shaders/4.2.texture.fs | 11 + 11-lightmaps/shaders/4.2.texture.vs | 15 + 11-lightmaps/src/camera.cpp | 63 + 11-lightmaps/src/camera.hpp | 27 + 11-lightmaps/src/data.hpp | 46 + 11-lightmaps/src/dbc.cpp | 47 + 11-lightmaps/src/dbc.hpp | 46 + 11-lightmaps/src/main.cpp | 334 + 11-lightmaps/src/mesh.cpp | 57 + 11-lightmaps/src/mesh.hpp | 42 + 11-lightmaps/src/model.cpp | 171 + 11-lightmaps/src/model.hpp | 40 + 11-lightmaps/src/physics.cpp | 49 + 11-lightmaps/src/physics.hpp | 13 + 11-lightmaps/src/shader.cpp | 126 + 11-lightmaps/src/shader.hpp | 53 + 11-lightmaps/src/stb_image.cpp | 2 + 11-lightmaps/src/stb_image.h | 7988 +++++++++++++++++ 11-lightmaps/tests/bad_shader.vs | 10 + 11-lightmaps/tests/main.cpp | 38 + 11-lightmaps/tests/meson.build | 4 + 11-lightmaps/tests/shader_tests.cpp | 33 + 11-lightmaps/wraps/assimp.wrap | 9 + 11-lightmaps/wraps/box2d.wrap | 13 + 11-lightmaps/wraps/fmt.wrap | 13 + 11-lightmaps/wraps/fuc2.wrap | 9 + 11-lightmaps/wraps/glfw.wrap | 13 + 11-lightmaps/wraps/glm.wrap | 13 + 447 files changed, 126678 insertions(+) create mode 100644 .gitignore create mode 100644 01-hello-triangle/.gitignore create mode 100644 01-hello-triangle/.vimrc_proj create mode 100644 01-hello-triangle/KHR/khrplatform.h create mode 100644 01-hello-triangle/LICENSE create mode 100644 01-hello-triangle/Makefile create mode 100644 01-hello-triangle/glad/glad.cpp create mode 100644 01-hello-triangle/glad/glad.h create mode 100644 01-hello-triangle/meson.build create mode 100644 01-hello-triangle/scripts/reset_build.ps1 create mode 100644 01-hello-triangle/scripts/reset_build.sh create mode 100644 01-hello-triangle/scripts/setup.ps1 create mode 100644 01-hello-triangle/scripts/setup.sh create mode 100644 01-hello-triangle/scripts/watch_build.sh create mode 100644 01-hello-triangle/scripts/windows_setup.ps1 create mode 100644 01-hello-triangle/src/dbc.cpp create mode 100644 01-hello-triangle/src/dbc.hpp create mode 100644 01-hello-triangle/src/main.cpp create mode 100644 01-hello-triangle/wraps/glfw.wrap create mode 100644 02-shader-class/.gitignore create mode 100644 02-shader-class/.vimrc_proj create mode 100644 02-shader-class/KHR/khrplatform.h create mode 100644 02-shader-class/LICENSE create mode 100644 02-shader-class/Makefile create mode 100644 02-shader-class/glad/glad.cpp create mode 100644 02-shader-class/glad/glad.h create mode 100644 02-shader-class/meson.build create mode 100644 02-shader-class/scripts/reset_build.ps1 create mode 100644 02-shader-class/scripts/reset_build.sh create mode 100644 02-shader-class/scripts/setup.ps1 create mode 100644 02-shader-class/scripts/setup.sh create mode 100644 02-shader-class/scripts/watch_build.sh create mode 100644 02-shader-class/scripts/windows_setup.ps1 create mode 100644 02-shader-class/shaders/3.3.shader.fs create mode 100644 02-shader-class/shaders/3.3.shader.vs create mode 100644 02-shader-class/src/dbc.cpp create mode 100644 02-shader-class/src/dbc.hpp create mode 100644 02-shader-class/src/main.cpp create mode 100644 02-shader-class/src/shader.cpp create mode 100644 02-shader-class/src/shader.hpp create mode 100644 02-shader-class/tests/bad_shader.vs create mode 100644 02-shader-class/tests/main.cpp create mode 100644 02-shader-class/tests/meson.build create mode 100644 02-shader-class/tests/shader_tests.cpp create mode 100644 02-shader-class/wraps/fmt.wrap create mode 100644 02-shader-class/wraps/fuc2.wrap create mode 100644 02-shader-class/wraps/glfw.wrap create mode 100644 03-textures/.gitignore create mode 100644 03-textures/.vimrc_proj create mode 100644 03-textures/KHR/khrplatform.h create mode 100644 03-textures/LICENSE create mode 100644 03-textures/Makefile create mode 100644 03-textures/glad/glad.cpp create mode 100644 03-textures/glad/glad.h create mode 100644 03-textures/meson.build create mode 100644 03-textures/resources/textures/awesomeface.png create mode 100644 03-textures/resources/textures/container.jpg create mode 100644 03-textures/scripts/reset_build.ps1 create mode 100644 03-textures/scripts/reset_build.sh create mode 100644 03-textures/scripts/setup.ps1 create mode 100644 03-textures/scripts/setup.sh create mode 100644 03-textures/scripts/watch_build.sh create mode 100644 03-textures/scripts/windows_setup.ps1 create mode 100644 03-textures/shaders/3.3.shader.fs create mode 100644 03-textures/shaders/3.3.shader.vs create mode 100644 03-textures/shaders/4.2.texture.fs create mode 100644 03-textures/shaders/4.2.texture.vs create mode 100644 03-textures/src/dbc.cpp create mode 100644 03-textures/src/dbc.hpp create mode 100644 03-textures/src/main.cpp create mode 100644 03-textures/src/shader.cpp create mode 100644 03-textures/src/shader.hpp create mode 100644 03-textures/src/stb_image.cpp create mode 100644 03-textures/src/stb_image.h create mode 100644 03-textures/tests/bad_shader.vs create mode 100644 03-textures/tests/main.cpp create mode 100644 03-textures/tests/meson.build create mode 100644 03-textures/tests/shader_tests.cpp create mode 100644 03-textures/wraps/fmt.wrap create mode 100644 03-textures/wraps/fuc2.wrap create mode 100644 03-textures/wraps/glfw.wrap create mode 100644 04-transformations/.gitignore create mode 100644 04-transformations/.vimrc_proj create mode 100644 04-transformations/KHR/khrplatform.h create mode 100644 04-transformations/LICENSE create mode 100644 04-transformations/Makefile create mode 100644 04-transformations/glad/glad.cpp create mode 100644 04-transformations/glad/glad.h create mode 100644 04-transformations/meson.build create mode 100644 04-transformations/resources/textures/awesomeface.png create mode 100644 04-transformations/resources/textures/container.jpg create mode 100644 04-transformations/scripts/reset_build.ps1 create mode 100644 04-transformations/scripts/reset_build.sh create mode 100644 04-transformations/scripts/setup.ps1 create mode 100644 04-transformations/scripts/setup.sh create mode 100644 04-transformations/scripts/watch_build.sh create mode 100644 04-transformations/scripts/windows_setup.ps1 create mode 100644 04-transformations/shaders/3.3.shader.fs create mode 100644 04-transformations/shaders/3.3.shader.vs create mode 100644 04-transformations/shaders/4.2.texture.fs create mode 100644 04-transformations/shaders/4.2.texture.vs create mode 100644 04-transformations/src/dbc.cpp create mode 100644 04-transformations/src/dbc.hpp create mode 100644 04-transformations/src/main.cpp create mode 100644 04-transformations/src/shader.cpp create mode 100644 04-transformations/src/shader.hpp create mode 100644 04-transformations/src/stb_image.cpp create mode 100644 04-transformations/src/stb_image.h create mode 100644 04-transformations/tests/bad_shader.vs create mode 100644 04-transformations/tests/main.cpp create mode 100644 04-transformations/tests/meson.build create mode 100644 04-transformations/tests/shader_tests.cpp create mode 100644 04-transformations/wraps/box2d.wrap create mode 100644 04-transformations/wraps/fmt.wrap create mode 100644 04-transformations/wraps/fuc2.wrap create mode 100644 04-transformations/wraps/glfw.wrap create mode 100644 04-transformations/wraps/glm.wrap create mode 100644 05-coordinate_systems/.gitignore create mode 100644 05-coordinate_systems/.vimrc_proj create mode 100644 05-coordinate_systems/KHR/khrplatform.h create mode 100644 05-coordinate_systems/LICENSE create mode 100644 05-coordinate_systems/Makefile create mode 100644 05-coordinate_systems/glad/glad.cpp create mode 100644 05-coordinate_systems/glad/glad.h create mode 100644 05-coordinate_systems/meson.build create mode 100644 05-coordinate_systems/resources/textures/awesomeface.png create mode 100644 05-coordinate_systems/resources/textures/container.jpg create mode 100644 05-coordinate_systems/scripts/reset_build.ps1 create mode 100644 05-coordinate_systems/scripts/reset_build.sh create mode 100644 05-coordinate_systems/scripts/setup.ps1 create mode 100644 05-coordinate_systems/scripts/setup.sh create mode 100644 05-coordinate_systems/scripts/watch_build.sh create mode 100644 05-coordinate_systems/scripts/windows_setup.ps1 create mode 100644 05-coordinate_systems/shaders/3.3.shader.fs create mode 100644 05-coordinate_systems/shaders/3.3.shader.vs create mode 100644 05-coordinate_systems/shaders/4.2.texture.fs create mode 100644 05-coordinate_systems/shaders/4.2.texture.vs create mode 100644 05-coordinate_systems/src/data.hpp create mode 100644 05-coordinate_systems/src/dbc.cpp create mode 100644 05-coordinate_systems/src/dbc.hpp create mode 100644 05-coordinate_systems/src/main.cpp create mode 100644 05-coordinate_systems/src/physics.cpp create mode 100644 05-coordinate_systems/src/physics.hpp create mode 100644 05-coordinate_systems/src/shader.cpp create mode 100644 05-coordinate_systems/src/shader.hpp create mode 100644 05-coordinate_systems/src/stb_image.cpp create mode 100644 05-coordinate_systems/src/stb_image.h create mode 100644 05-coordinate_systems/tests/bad_shader.vs create mode 100644 05-coordinate_systems/tests/main.cpp create mode 100644 05-coordinate_systems/tests/meson.build create mode 100644 05-coordinate_systems/tests/shader_tests.cpp create mode 100644 05-coordinate_systems/wraps/box2d.wrap create mode 100644 05-coordinate_systems/wraps/fmt.wrap create mode 100644 05-coordinate_systems/wraps/fuc2.wrap create mode 100644 05-coordinate_systems/wraps/glfw.wrap create mode 100644 05-coordinate_systems/wraps/glm.wrap create mode 100644 06-camera/.gitignore create mode 100644 06-camera/.vimrc_proj create mode 100644 06-camera/KHR/khrplatform.h create mode 100644 06-camera/LICENSE create mode 100644 06-camera/Makefile create mode 100644 06-camera/glad/glad.cpp create mode 100644 06-camera/glad/glad.h create mode 100644 06-camera/meson.build create mode 100644 06-camera/resources/textures/awesomeface.png create mode 100644 06-camera/resources/textures/container.jpg create mode 100644 06-camera/scripts/reset_build.ps1 create mode 100644 06-camera/scripts/reset_build.sh create mode 100644 06-camera/scripts/setup.ps1 create mode 100644 06-camera/scripts/setup.sh create mode 100644 06-camera/scripts/watch_build.sh create mode 100644 06-camera/scripts/windows_setup.ps1 create mode 100644 06-camera/shaders/3.3.shader.fs create mode 100644 06-camera/shaders/3.3.shader.vs create mode 100644 06-camera/shaders/4.2.texture.fs create mode 100644 06-camera/shaders/4.2.texture.vs create mode 100644 06-camera/src/data.hpp create mode 100644 06-camera/src/dbc.cpp create mode 100644 06-camera/src/dbc.hpp create mode 100644 06-camera/src/main.cpp create mode 100644 06-camera/src/physics.cpp create mode 100644 06-camera/src/physics.hpp create mode 100644 06-camera/src/shader.cpp create mode 100644 06-camera/src/shader.hpp create mode 100644 06-camera/src/stb_image.cpp create mode 100644 06-camera/src/stb_image.h create mode 100644 06-camera/tests/bad_shader.vs create mode 100644 06-camera/tests/main.cpp create mode 100644 06-camera/tests/meson.build create mode 100644 06-camera/tests/shader_tests.cpp create mode 100644 06-camera/wraps/box2d.wrap create mode 100644 06-camera/wraps/fmt.wrap create mode 100644 06-camera/wraps/fuc2.wrap create mode 100644 06-camera/wraps/glfw.wrap create mode 100644 06-camera/wraps/glm.wrap create mode 100644 07-model-loading/.gitignore create mode 100644 07-model-loading/.vimrc_proj create mode 100644 07-model-loading/KHR/khrplatform.h create mode 100644 07-model-loading/LICENSE create mode 100644 07-model-loading/Makefile create mode 100644 07-model-loading/assets/popcorn_model_a.glb create mode 100644 07-model-loading/glad/glad.cpp create mode 100644 07-model-loading/glad/glad.h create mode 100644 07-model-loading/meson.build create mode 100644 07-model-loading/resources/textures/awesomeface.png create mode 100644 07-model-loading/resources/textures/container.jpg create mode 100644 07-model-loading/resources/textures/popcorn.jpg create mode 100644 07-model-loading/scripts/reset_build.ps1 create mode 100644 07-model-loading/scripts/reset_build.sh create mode 100644 07-model-loading/scripts/setup.ps1 create mode 100644 07-model-loading/scripts/setup.sh create mode 100644 07-model-loading/scripts/watch_build.sh create mode 100644 07-model-loading/scripts/windows_setup.ps1 create mode 100644 07-model-loading/shaders/3.3.shader.fs create mode 100644 07-model-loading/shaders/3.3.shader.vs create mode 100644 07-model-loading/shaders/4.2.texture.fs create mode 100644 07-model-loading/shaders/4.2.texture.vs create mode 100644 07-model-loading/src/data.hpp create mode 100644 07-model-loading/src/dbc.cpp create mode 100644 07-model-loading/src/dbc.hpp create mode 100644 07-model-loading/src/main.cpp create mode 100644 07-model-loading/src/mesh.cpp create mode 100644 07-model-loading/src/mesh.hpp create mode 100644 07-model-loading/src/model.cpp create mode 100644 07-model-loading/src/model.hpp create mode 100644 07-model-loading/src/physics.cpp create mode 100644 07-model-loading/src/physics.hpp create mode 100644 07-model-loading/src/shader.cpp create mode 100644 07-model-loading/src/shader.hpp create mode 100644 07-model-loading/src/stb_image.cpp create mode 100644 07-model-loading/src/stb_image.h create mode 100644 07-model-loading/tests/bad_shader.vs create mode 100644 07-model-loading/tests/main.cpp create mode 100644 07-model-loading/tests/meson.build create mode 100644 07-model-loading/tests/shader_tests.cpp create mode 100644 07-model-loading/wraps/assimp.wrap create mode 100644 07-model-loading/wraps/box2d.wrap create mode 100644 07-model-loading/wraps/fmt.wrap create mode 100644 07-model-loading/wraps/fuc2.wrap create mode 100644 07-model-loading/wraps/glfw.wrap create mode 100644 07-model-loading/wraps/glm.wrap create mode 100644 08-colors-basic-light/.gitignore create mode 100644 08-colors-basic-light/.vimrc_proj create mode 100644 08-colors-basic-light/KHR/khrplatform.h create mode 100644 08-colors-basic-light/LICENSE create mode 100644 08-colors-basic-light/Makefile create mode 100644 08-colors-basic-light/assets/popcorn_model_a.glb create mode 100644 08-colors-basic-light/glad/glad.cpp create mode 100644 08-colors-basic-light/glad/glad.h create mode 100644 08-colors-basic-light/meson.build create mode 100644 08-colors-basic-light/resources/textures/awesomeface.png create mode 100644 08-colors-basic-light/resources/textures/container.jpg create mode 100644 08-colors-basic-light/resources/textures/popcorn.jpg create mode 100644 08-colors-basic-light/scripts/reset_build.ps1 create mode 100644 08-colors-basic-light/scripts/reset_build.sh create mode 100644 08-colors-basic-light/scripts/setup.ps1 create mode 100644 08-colors-basic-light/scripts/setup.sh create mode 100644 08-colors-basic-light/scripts/watch_build.sh create mode 100644 08-colors-basic-light/scripts/windows_setup.ps1 create mode 100644 08-colors-basic-light/shaders/08-frag.glsl create mode 100644 08-colors-basic-light/shaders/08-lightsource.frag.glsl create mode 100644 08-colors-basic-light/shaders/08-vert.glsl create mode 100644 08-colors-basic-light/shaders/3.3.shader.fs create mode 100644 08-colors-basic-light/shaders/3.3.shader.vs create mode 100644 08-colors-basic-light/shaders/4.2.texture.fs create mode 100644 08-colors-basic-light/shaders/4.2.texture.vs create mode 100644 08-colors-basic-light/src/camera.cpp create mode 100644 08-colors-basic-light/src/camera.hpp create mode 100644 08-colors-basic-light/src/data.hpp create mode 100644 08-colors-basic-light/src/dbc.cpp create mode 100644 08-colors-basic-light/src/dbc.hpp create mode 100644 08-colors-basic-light/src/main.cpp create mode 100644 08-colors-basic-light/src/mesh.cpp create mode 100644 08-colors-basic-light/src/mesh.hpp create mode 100644 08-colors-basic-light/src/model.cpp create mode 100644 08-colors-basic-light/src/model.hpp create mode 100644 08-colors-basic-light/src/physics.cpp create mode 100644 08-colors-basic-light/src/physics.hpp create mode 100644 08-colors-basic-light/src/shader.cpp create mode 100644 08-colors-basic-light/src/shader.hpp create mode 100644 08-colors-basic-light/src/stb_image.cpp create mode 100644 08-colors-basic-light/src/stb_image.h create mode 100644 08-colors-basic-light/tests/bad_shader.vs create mode 100644 08-colors-basic-light/tests/main.cpp create mode 100644 08-colors-basic-light/tests/meson.build create mode 100644 08-colors-basic-light/tests/shader_tests.cpp create mode 100644 08-colors-basic-light/wraps/assimp.wrap create mode 100644 08-colors-basic-light/wraps/box2d.wrap create mode 100644 08-colors-basic-light/wraps/fmt.wrap create mode 100644 08-colors-basic-light/wraps/fuc2.wrap create mode 100644 08-colors-basic-light/wraps/glfw.wrap create mode 100644 08-colors-basic-light/wraps/glm.wrap create mode 100644 09-basic-light-materials/.gitignore create mode 100644 09-basic-light-materials/.vimrc_proj create mode 100644 09-basic-light-materials/KHR/khrplatform.h create mode 100644 09-basic-light-materials/LICENSE create mode 100644 09-basic-light-materials/Makefile create mode 100644 09-basic-light-materials/assets/popcorn_model_a.glb create mode 100644 09-basic-light-materials/assets/popcorn_model_a.mtl create mode 100644 09-basic-light-materials/assets/popcorn_model_a.obj create mode 100644 09-basic-light-materials/glad/glad.cpp create mode 100644 09-basic-light-materials/glad/glad.h create mode 100644 09-basic-light-materials/meson.build create mode 100644 09-basic-light-materials/resources/textures/awesomeface.png create mode 100644 09-basic-light-materials/resources/textures/container.jpg create mode 100644 09-basic-light-materials/resources/textures/popcorn.jpg create mode 100644 09-basic-light-materials/scripts/reset_build.ps1 create mode 100644 09-basic-light-materials/scripts/reset_build.sh create mode 100644 09-basic-light-materials/scripts/setup.ps1 create mode 100644 09-basic-light-materials/scripts/setup.sh create mode 100644 09-basic-light-materials/scripts/watch_build.sh create mode 100644 09-basic-light-materials/scripts/windows_setup.ps1 create mode 100644 09-basic-light-materials/shaders/08-frag.glsl create mode 100644 09-basic-light-materials/shaders/08-lightsource.frag.glsl create mode 100644 09-basic-light-materials/shaders/08-vert.glsl create mode 100644 09-basic-light-materials/shaders/3.3.shader.fs create mode 100644 09-basic-light-materials/shaders/3.3.shader.vs create mode 100644 09-basic-light-materials/shaders/4.2.texture.fs create mode 100644 09-basic-light-materials/shaders/4.2.texture.vs create mode 100644 09-basic-light-materials/src/camera.cpp create mode 100644 09-basic-light-materials/src/camera.hpp create mode 100644 09-basic-light-materials/src/data.hpp create mode 100644 09-basic-light-materials/src/dbc.cpp create mode 100644 09-basic-light-materials/src/dbc.hpp create mode 100644 09-basic-light-materials/src/main.cpp create mode 100644 09-basic-light-materials/src/mesh.cpp create mode 100644 09-basic-light-materials/src/mesh.hpp create mode 100644 09-basic-light-materials/src/model.cpp create mode 100644 09-basic-light-materials/src/model.hpp create mode 100644 09-basic-light-materials/src/physics.cpp create mode 100644 09-basic-light-materials/src/physics.hpp create mode 100644 09-basic-light-materials/src/shader.cpp create mode 100644 09-basic-light-materials/src/shader.hpp create mode 100644 09-basic-light-materials/src/stb_image.cpp create mode 100644 09-basic-light-materials/src/stb_image.h create mode 100644 09-basic-light-materials/tests/bad_shader.vs create mode 100644 09-basic-light-materials/tests/main.cpp create mode 100644 09-basic-light-materials/tests/meson.build create mode 100644 09-basic-light-materials/tests/shader_tests.cpp create mode 100644 09-basic-light-materials/wraps/assimp.wrap create mode 100644 09-basic-light-materials/wraps/box2d.wrap create mode 100644 09-basic-light-materials/wraps/fmt.wrap create mode 100644 09-basic-light-materials/wraps/fuc2.wrap create mode 100644 09-basic-light-materials/wraps/glfw.wrap create mode 100644 09-basic-light-materials/wraps/glm.wrap create mode 100644 10-materials/.gitignore create mode 100644 10-materials/.vimrc_proj create mode 100644 10-materials/KHR/khrplatform.h create mode 100644 10-materials/LICENSE create mode 100644 10-materials/Makefile create mode 100644 10-materials/assets/popcorn_model_a.glb create mode 100644 10-materials/glad/glad.cpp create mode 100644 10-materials/glad/glad.h create mode 100644 10-materials/meson.build create mode 100644 10-materials/resources/textures/awesomeface.png create mode 100644 10-materials/resources/textures/container.jpg create mode 100644 10-materials/resources/textures/popcorn.jpg create mode 100644 10-materials/scripts/reset_build.ps1 create mode 100644 10-materials/scripts/reset_build.sh create mode 100644 10-materials/scripts/setup.ps1 create mode 100644 10-materials/scripts/setup.sh create mode 100644 10-materials/scripts/watch_build.sh create mode 100644 10-materials/scripts/windows_setup.ps1 create mode 100644 10-materials/shaders/08-frag.glsl create mode 100644 10-materials/shaders/08-lightsource.frag.glsl create mode 100644 10-materials/shaders/08-vert.glsl create mode 100644 10-materials/shaders/3.3.shader.fs create mode 100644 10-materials/shaders/3.3.shader.vs create mode 100644 10-materials/shaders/4.2.texture.fs create mode 100644 10-materials/shaders/4.2.texture.vs create mode 100644 10-materials/src/camera.cpp create mode 100644 10-materials/src/camera.hpp create mode 100644 10-materials/src/data.hpp create mode 100644 10-materials/src/dbc.cpp create mode 100644 10-materials/src/dbc.hpp create mode 100644 10-materials/src/main.cpp create mode 100644 10-materials/src/mesh.cpp create mode 100644 10-materials/src/mesh.hpp create mode 100644 10-materials/src/model.cpp create mode 100644 10-materials/src/model.hpp create mode 100644 10-materials/src/physics.cpp create mode 100644 10-materials/src/physics.hpp create mode 100644 10-materials/src/shader.cpp create mode 100644 10-materials/src/shader.hpp create mode 100644 10-materials/src/stb_image.cpp create mode 100644 10-materials/src/stb_image.h create mode 100644 10-materials/tests/bad_shader.vs create mode 100644 10-materials/tests/main.cpp create mode 100644 10-materials/tests/meson.build create mode 100644 10-materials/tests/shader_tests.cpp create mode 100644 10-materials/wraps/assimp.wrap create mode 100644 10-materials/wraps/box2d.wrap create mode 100644 10-materials/wraps/fmt.wrap create mode 100644 10-materials/wraps/fuc2.wrap create mode 100644 10-materials/wraps/glfw.wrap create mode 100644 10-materials/wraps/glm.wrap create mode 100644 11-lightmaps/.gitignore create mode 100644 11-lightmaps/.vimrc_proj create mode 100644 11-lightmaps/KHR/khrplatform.h create mode 100644 11-lightmaps/LICENSE create mode 100644 11-lightmaps/Makefile create mode 100644 11-lightmaps/assets/popcorn_model_a.glb create mode 100644 11-lightmaps/glad/glad.cpp create mode 100644 11-lightmaps/glad/glad.h create mode 100644 11-lightmaps/meson.build create mode 100644 11-lightmaps/resources/textures/awesomeface.png create mode 100644 11-lightmaps/resources/textures/container.jpg create mode 100644 11-lightmaps/resources/textures/popcorn.jpg create mode 100644 11-lightmaps/scripts/reset_build.ps1 create mode 100644 11-lightmaps/scripts/reset_build.sh create mode 100644 11-lightmaps/scripts/setup.ps1 create mode 100644 11-lightmaps/scripts/setup.sh create mode 100644 11-lightmaps/scripts/watch_build.sh create mode 100644 11-lightmaps/scripts/windows_setup.ps1 create mode 100644 11-lightmaps/shaders/08-frag.glsl create mode 100644 11-lightmaps/shaders/08-lightsource.frag.glsl create mode 100644 11-lightmaps/shaders/08-vert.glsl create mode 100644 11-lightmaps/shaders/3.3.shader.fs create mode 100644 11-lightmaps/shaders/3.3.shader.vs create mode 100644 11-lightmaps/shaders/4.2.texture.fs create mode 100644 11-lightmaps/shaders/4.2.texture.vs create mode 100644 11-lightmaps/src/camera.cpp create mode 100644 11-lightmaps/src/camera.hpp create mode 100644 11-lightmaps/src/data.hpp create mode 100644 11-lightmaps/src/dbc.cpp create mode 100644 11-lightmaps/src/dbc.hpp create mode 100644 11-lightmaps/src/main.cpp create mode 100644 11-lightmaps/src/mesh.cpp create mode 100644 11-lightmaps/src/mesh.hpp create mode 100644 11-lightmaps/src/model.cpp create mode 100644 11-lightmaps/src/model.hpp create mode 100644 11-lightmaps/src/physics.cpp create mode 100644 11-lightmaps/src/physics.hpp create mode 100644 11-lightmaps/src/shader.cpp create mode 100644 11-lightmaps/src/shader.hpp create mode 100644 11-lightmaps/src/stb_image.cpp create mode 100644 11-lightmaps/src/stb_image.h create mode 100644 11-lightmaps/tests/bad_shader.vs create mode 100644 11-lightmaps/tests/main.cpp create mode 100644 11-lightmaps/tests/meson.build create mode 100644 11-lightmaps/tests/shader_tests.cpp create mode 100644 11-lightmaps/wraps/assimp.wrap create mode 100644 11-lightmaps/wraps/box2d.wrap create mode 100644 11-lightmaps/wraps/fmt.wrap create mode 100644 11-lightmaps/wraps/fuc2.wrap create mode 100644 11-lightmaps/wraps/glfw.wrap create mode 100644 11-lightmaps/wraps/glm.wrap diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..47aeb51 --- /dev/null +++ b/.gitignore @@ -0,0 +1,13 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects +*.exe +*.dll +*.so diff --git a/01-hello-triangle/.gitignore b/01-hello-triangle/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/01-hello-triangle/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/01-hello-triangle/.vimrc_proj b/01-hello-triangle/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/01-hello-triangle/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/01-hello-triangle/KHR/khrplatform.h b/01-hello-triangle/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/01-hello-triangle/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/01-hello-triangle/LICENSE b/01-hello-triangle/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/01-hello-triangle/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/01-hello-triangle/Makefile b/01-hello-triangle/Makefile new file mode 100644 index 0000000..3e9a4d7 --- /dev/null +++ b/01-hello-triangle/Makefile @@ -0,0 +1,27 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: build + ./builddir/hellogl.exe + +debug: build + gdb --nx -x .gdbinit --ex run --args builddir/runtests.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/01-hello-triangle/glad/glad.cpp b/01-hello-triangle/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/01-hello-triangle/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/01-hello-triangle/glad/glad.h b/01-hello-triangle/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/01-hello-triangle/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/01-hello-triangle/meson.build b/01-hello-triangle/meson.build new file mode 100644 index 0000000..399dff8 --- /dev/null +++ b/01-hello-triangle/meson.build @@ -0,0 +1,76 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') + +dependencies += [ + glfw3 +] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', +] + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/01-hello-triangle/scripts/reset_build.ps1 b/01-hello-triangle/scripts/reset_build.ps1 new file mode 100644 index 0000000..975852d --- /dev/null +++ b/01-hello-triangle/scripts/reset_build.ps1 @@ -0,0 +1,7 @@ +mv .\subprojects\packagecache . +rm -recurse -force .\subprojects\,.\builddir\ +mkdir subprojects +mv .\packagecache .\subprojects\ +mkdir builddir +cp wraps\*.wrap subprojects\ +meson setup --default-library=static --prefer-static builddir diff --git a/01-hello-triangle/scripts/reset_build.sh b/01-hello-triangle/scripts/reset_build.sh new file mode 100644 index 0000000..89931e7 --- /dev/null +++ b/01-hello-triangle/scripts/reset_build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +mv -f ./subprojects/packagecache . +rm -rf subprojects builddir +mkdir subprojects +mv -f packagecache ./subprojects/ && true +mkdir builddir +cp wraps/*.wrap subprojects/ +# on OSX you can't do this with static +meson setup --default-library=static --prefer-static builddir diff --git a/01-hello-triangle/scripts/setup.ps1 b/01-hello-triangle/scripts/setup.ps1 new file mode 100644 index 0000000..050d716 --- /dev/null +++ b/01-hello-triangle/scripts/setup.ps1 @@ -0,0 +1,4 @@ +mkdir builddir +mkdir subprojects +cp wraps/*.wrap subprojects +meson setup -Ddefault_library=static builddir diff --git a/01-hello-triangle/scripts/setup.sh b/01-hello-triangle/scripts/setup.sh new file mode 100644 index 0000000..7881736 --- /dev/null +++ b/01-hello-triangle/scripts/setup.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +set -ex + +mkdir subprojects +mkdir builddir +cp wraps/*.wrap subprojects/ +meson setup builddir diff --git a/01-hello-triangle/scripts/watch_build.sh b/01-hello-triangle/scripts/watch_build.sh new file mode 100644 index 0000000..44a5516 --- /dev/null +++ b/01-hello-triangle/scripts/watch_build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +fswatch -o *.cpp | while read num +do echo ">>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/01-hello-triangle/scripts/windows_setup.ps1 b/01-hello-triangle/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/01-hello-triangle/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/01-hello-triangle/src/dbc.cpp b/01-hello-triangle/src/dbc.cpp new file mode 100644 index 0000000..7e1fbde --- /dev/null +++ b/01-hello-triangle/src/dbc.cpp @@ -0,0 +1,48 @@ +#include "dbc.hpp" +#include +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = std::format("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError{err}; +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = std::format("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError{err}; + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = std::format("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError{err}; + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = std::format("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError{err}; + } +} diff --git a/01-hello-triangle/src/dbc.hpp b/01-hello-triangle/src/dbc.hpp new file mode 100644 index 0000000..e3757b0 --- /dev/null +++ b/01-hello-triangle/src/dbc.hpp @@ -0,0 +1,49 @@ +#pragma once + +#include +#include +#include + +using std::string; + +namespace dbc { + class Error { + public: + const string message; + Error(string m) : message{m} {} + Error(const char *m) : message{m} {} + }; + + class CheckError : public Error {}; + class SentinelError : public Error {}; + class PreCondError : public Error {}; + class PostCondError : public Error {}; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/01-hello-triangle/src/main.cpp b/01-hello-triangle/src/main.cpp new file mode 100644 index 0000000..b8671cc --- /dev/null +++ b/01-hello-triangle/src/main.cpp @@ -0,0 +1,188 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include + +void framebuffer_size_callback(GLFWwindow *window, int widht, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + unsigned int shaderProgram = 0; + unsigned int VAO = 0; + unsigned int EBO = 0; +}; + +const char *vertexShaderSource = "#version 330 core\n" + "layout (location = 0) in vec3 aPos;\n" + "void main()\n" + "{\n" + " gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);\n" + "}\0"; + +const char *fragmentShaderSource = "#version 330 core\n" + "out vec4 FragColor;\n" + "void main()\n" + "{\n" + " FragColor = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n" + "}\n\0"; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + return window; +} + +void processInput(GLFWwindow *window) { + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } +} + +void check_status(const char* what, unsigned int shader, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(shader, check_type, &success); + } else { + glGetShaderiv(shader, check_type, &success); + } + + if(!success) { + glGetShaderInfoLog(shader, 512, NULL, infoLog); + std::println("ERROR: Shader {} compile failed: {}", what, infoLog); + } +} + +Config setup() { + unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); + glCompileShader(vertexShader); + check_status("vertex shader", vertexShader, GL_COMPILE_STATUS); + + unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); + glCompileShader(fragmentShader); + check_status("fragment shader", fragmentShader, GL_COMPILE_STATUS); + + unsigned int shaderProgram = glCreateProgram(); + glAttachShader(shaderProgram, vertexShader); + glAttachShader(shaderProgram, fragmentShader); + glLinkProgram(shaderProgram); + check_status("shader program", shaderProgram, GL_LINK_STATUS); + + glDeleteShader(vertexShader); + glDeleteShader(fragmentShader); + + float vertices[] = { + 0.5f, 0.5f, 0.0f, // top right + 0.5f, -0.5f, 0.0f, // bottom right + -0.5f, -0.5f, 0.0f, // bottom left + -0.5f, 0.5f, 0.0f // top left + }; + + unsigned int indices[] = { // note that we start from 0! + 0, 1, 3, // first Triangle + 1, 2, 3 // second Triangle + }; + + unsigned int VBO = 0; + unsigned int VAO = 0; + unsigned int EBO = 0; + + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); + + // 0 in arg one matches the vertexShader, line 1, location=0 + // this attaches the vertices to that location in the shader + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + // unbinds the magic currently active buffer + glBindBuffer(GL_ARRAY_BUFFER, 0); + + // remember: do NOT unbind the EBO while a VAO is active as the bound element buffer object IS stored in the VAO; keep the EBO bound. + //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + + glBindVertexArray(0); + + // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + + return { + .shaderProgram = shaderProgram, + .VAO = VAO, + .EBO = EBO}; +} + +void render(GLFWwindow* window, const Config& config) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + glUseProgram(config.shaderProgram); + glBindVertexArray(config.VAO); + + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.VAO); + glDeleteBuffers(1, &config.VAO); + glDeleteBuffers(1, &config.EBO); + glDeleteProgram(config.shaderProgram); +} + +int main() { + init_glfw(); + + auto window = create_window(); + + auto config = setup(); + + while(!glfwWindowShouldClose(window)) { + processInput(window); + render(window, config); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/01-hello-triangle/wraps/glfw.wrap b/01-hello-triangle/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/01-hello-triangle/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/02-shader-class/.gitignore b/02-shader-class/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/02-shader-class/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/02-shader-class/.vimrc_proj b/02-shader-class/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/02-shader-class/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/02-shader-class/KHR/khrplatform.h b/02-shader-class/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/02-shader-class/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/02-shader-class/LICENSE b/02-shader-class/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/02-shader-class/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/02-shader-class/Makefile b/02-shader-class/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/02-shader-class/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/02-shader-class/glad/glad.cpp b/02-shader-class/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/02-shader-class/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/02-shader-class/glad/glad.h b/02-shader-class/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/02-shader-class/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/02-shader-class/meson.build b/02-shader-class/meson.build new file mode 100644 index 0000000..cc96b45 --- /dev/null +++ b/02-shader-class/meson.build @@ -0,0 +1,91 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') + +dependencies += [ + glfw3, fuc2, fmt +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/shader.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/02-shader-class/scripts/reset_build.ps1 b/02-shader-class/scripts/reset_build.ps1 new file mode 100644 index 0000000..975852d --- /dev/null +++ b/02-shader-class/scripts/reset_build.ps1 @@ -0,0 +1,7 @@ +mv .\subprojects\packagecache . +rm -recurse -force .\subprojects\,.\builddir\ +mkdir subprojects +mv .\packagecache .\subprojects\ +mkdir builddir +cp wraps\*.wrap subprojects\ +meson setup --default-library=static --prefer-static builddir diff --git a/02-shader-class/scripts/reset_build.sh b/02-shader-class/scripts/reset_build.sh new file mode 100644 index 0000000..89931e7 --- /dev/null +++ b/02-shader-class/scripts/reset_build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +mv -f ./subprojects/packagecache . +rm -rf subprojects builddir +mkdir subprojects +mv -f packagecache ./subprojects/ && true +mkdir builddir +cp wraps/*.wrap subprojects/ +# on OSX you can't do this with static +meson setup --default-library=static --prefer-static builddir diff --git a/02-shader-class/scripts/setup.ps1 b/02-shader-class/scripts/setup.ps1 new file mode 100644 index 0000000..050d716 --- /dev/null +++ b/02-shader-class/scripts/setup.ps1 @@ -0,0 +1,4 @@ +mkdir builddir +mkdir subprojects +cp wraps/*.wrap subprojects +meson setup -Ddefault_library=static builddir diff --git a/02-shader-class/scripts/setup.sh b/02-shader-class/scripts/setup.sh new file mode 100644 index 0000000..7881736 --- /dev/null +++ b/02-shader-class/scripts/setup.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +set -ex + +mkdir subprojects +mkdir builddir +cp wraps/*.wrap subprojects/ +meson setup builddir diff --git a/02-shader-class/scripts/watch_build.sh b/02-shader-class/scripts/watch_build.sh new file mode 100644 index 0000000..44a5516 --- /dev/null +++ b/02-shader-class/scripts/watch_build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +fswatch -o *.cpp | while read num +do echo ">>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/02-shader-class/scripts/windows_setup.ps1 b/02-shader-class/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/02-shader-class/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/02-shader-class/shaders/3.3.shader.fs b/02-shader-class/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/02-shader-class/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/02-shader-class/shaders/3.3.shader.vs b/02-shader-class/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/02-shader-class/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/02-shader-class/src/dbc.cpp b/02-shader-class/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/02-shader-class/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/02-shader-class/src/dbc.hpp b/02-shader-class/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/02-shader-class/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/02-shader-class/src/main.cpp b/02-shader-class/src/main.cpp new file mode 100644 index 0000000..efebeee --- /dev/null +++ b/02-shader-class/src/main.cpp @@ -0,0 +1,133 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int widht, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + Shader shader; + unsigned int VAO = 0; +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + return window; +} + +void processInput(GLFWwindow *window) { + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } +} + +Config setup() { + Config config{{"shaders/3.3.shader.vs", "shaders/3.3.shader.fs"}}; + config.shader.use(); + config.shader.setVec4("incolor", 0.0f, 0.5f, 0.0f, 1.0); + + // set up vertex data (and buffer(s)) and configure vertex attributes + // ------------------------------------------------------------------ + float vertices[] = { + // positions // colors + 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom right + -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, // bottom left + 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f // top + }; + + unsigned int VBO = 0; + unsigned int VAO = 0; + + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + + glBindVertexArray(VAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + // 0 in arg one matches the vertexShader, line 1, location=0 + // this attaches the vertices to that location in the shader + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + // unbinds the magic currently active buffer + glBindBuffer(GL_ARRAY_BUFFER, 0); + + glBindVertexArray(0); + + // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); + + config.VAO = VAO; + + return config; +} + +void render(GLFWwindow* window, const Config& config) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + config.shader.use(); + glBindVertexArray(config.VAO); + glDrawArrays(GL_TRIANGLES, 0, 3); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.VAO); + glDeleteBuffers(1, &config.VAO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + auto window = create_window(); + + auto config = setup(); + + while(!glfwWindowShouldClose(window)) { + processInput(window); + render(window, config); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/02-shader-class/src/shader.cpp b/02-shader-class/src/shader.cpp new file mode 100644 index 0000000..98c8633 --- /dev/null +++ b/02-shader-class/src/shader.cpp @@ -0,0 +1,101 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} diff --git a/02-shader-class/src/shader.hpp b/02-shader-class/src/shader.hpp new file mode 100644 index 0000000..7f59481 --- /dev/null +++ b/02-shader-class/src/shader.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void cleanup(); +}; diff --git a/02-shader-class/tests/bad_shader.vs b/02-shader-class/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/02-shader-class/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/02-shader-class/tests/main.cpp b/02-shader-class/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/02-shader-class/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/02-shader-class/tests/meson.build b/02-shader-class/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/02-shader-class/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/02-shader-class/tests/shader_tests.cpp b/02-shader-class/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/02-shader-class/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/02-shader-class/wraps/fmt.wrap b/02-shader-class/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/02-shader-class/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/02-shader-class/wraps/fuc2.wrap b/02-shader-class/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/02-shader-class/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/02-shader-class/wraps/glfw.wrap b/02-shader-class/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/02-shader-class/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/03-textures/.gitignore b/03-textures/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/03-textures/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/03-textures/.vimrc_proj b/03-textures/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/03-textures/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/03-textures/KHR/khrplatform.h b/03-textures/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/03-textures/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/03-textures/LICENSE b/03-textures/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/03-textures/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/03-textures/Makefile b/03-textures/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/03-textures/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/03-textures/glad/glad.cpp b/03-textures/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/03-textures/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/03-textures/glad/glad.h b/03-textures/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/03-textures/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/03-textures/meson.build b/03-textures/meson.build new file mode 100644 index 0000000..0c1ab5a --- /dev/null +++ b/03-textures/meson.build @@ -0,0 +1,92 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') + +dependencies += [ + glfw3, fuc2, fmt +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/03-textures/resources/textures/awesomeface.png b/03-textures/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 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 Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/03-textures/resources/textures/container.jpg b/03-textures/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys 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[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/03-textures/scripts/reset_build.ps1 b/03-textures/scripts/reset_build.ps1 new file mode 100644 index 0000000..975852d --- /dev/null +++ b/03-textures/scripts/reset_build.ps1 @@ -0,0 +1,7 @@ +mv .\subprojects\packagecache . +rm -recurse -force .\subprojects\,.\builddir\ +mkdir subprojects +mv .\packagecache .\subprojects\ +mkdir builddir +cp wraps\*.wrap subprojects\ +meson setup --default-library=static --prefer-static builddir diff --git a/03-textures/scripts/reset_build.sh b/03-textures/scripts/reset_build.sh new file mode 100644 index 0000000..89931e7 --- /dev/null +++ b/03-textures/scripts/reset_build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +mv -f ./subprojects/packagecache . +rm -rf subprojects builddir +mkdir subprojects +mv -f packagecache ./subprojects/ && true +mkdir builddir +cp wraps/*.wrap subprojects/ +# on OSX you can't do this with static +meson setup --default-library=static --prefer-static builddir diff --git a/03-textures/scripts/setup.ps1 b/03-textures/scripts/setup.ps1 new file mode 100644 index 0000000..050d716 --- /dev/null +++ b/03-textures/scripts/setup.ps1 @@ -0,0 +1,4 @@ +mkdir builddir +mkdir subprojects +cp wraps/*.wrap subprojects +meson setup -Ddefault_library=static builddir diff --git a/03-textures/scripts/setup.sh b/03-textures/scripts/setup.sh new file mode 100644 index 0000000..7881736 --- /dev/null +++ b/03-textures/scripts/setup.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +set -ex + +mkdir subprojects +mkdir builddir +cp wraps/*.wrap subprojects/ +meson setup builddir diff --git a/03-textures/scripts/watch_build.sh b/03-textures/scripts/watch_build.sh new file mode 100644 index 0000000..44a5516 --- /dev/null +++ b/03-textures/scripts/watch_build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +fswatch -o *.cpp | while read num +do echo ">>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/03-textures/scripts/windows_setup.ps1 b/03-textures/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/03-textures/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/03-textures/shaders/3.3.shader.fs b/03-textures/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/03-textures/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/03-textures/shaders/3.3.shader.vs b/03-textures/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/03-textures/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/03-textures/shaders/4.2.texture.fs b/03-textures/shaders/4.2.texture.fs new file mode 100644 index 0000000..18554bd --- /dev/null +++ b/03-textures/shaders/4.2.texture.fs @@ -0,0 +1,14 @@ +#version 330 core + +out vec4 FragColor; + +in vec3 ourColor; +in vec2 TexCoord; + +uniform sampler2D texture1; +uniform sampler2D texture2; + +void main() +{ + FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2); +} diff --git a/03-textures/shaders/4.2.texture.vs b/03-textures/shaders/4.2.texture.vs new file mode 100644 index 0000000..d01a8a7 --- /dev/null +++ b/03-textures/shaders/4.2.texture.vs @@ -0,0 +1,14 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aColor; +layout (location = 2) in vec2 aTexCoord; + +out vec3 ourColor; +out vec2 TexCoord; + +void main() +{ + gl_Position = vec4(aPos, 1.0); + ourColor = aColor; + TexCoord = aTexCoord; +} diff --git a/03-textures/src/dbc.cpp b/03-textures/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/03-textures/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/03-textures/src/dbc.hpp b/03-textures/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/03-textures/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/03-textures/src/main.cpp b/03-textures/src/main.cpp new file mode 100644 index 0000000..e0ce210 --- /dev/null +++ b/03-textures/src/main.cpp @@ -0,0 +1,192 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + Shader shader; + unsigned int VAO = 0; + unsigned int VBO = 0; + unsigned int EBO = 0; + unsigned int texture1 = 0; + unsigned int texture2 = 0; +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + return window; +} + +void processInput(GLFWwindow *window) { + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + Config config{{"shaders/4.2.texture.vs", "shaders/4.2.texture.fs"}}; + + float vertices[] = { + // positions // colors // texture coords + 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top right + 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom right + -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom left + -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // top left + }; + unsigned int indices[] = { + 0, 1, 3, // first triangle + 1, 2, 3 // second triangle + }; + + unsigned int VBO = 0; + unsigned int VAO = 0; + unsigned int EBO = 0; + + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float))); + glEnableVertexAttribArray(2); + + config.texture1 = load_texture("resources/textures/container.jpg"); + + config.texture2 = load_texture("resources/textures/awesomeface.png"); + + config.shader.use(); + + glUniform1i(glGetUniformLocation(config.shader.ID, "texture1"), 0); + + config.shader.setInt("texture2", 1); + + config.VAO = VAO; + config.VBO = VBO; + config.EBO = EBO; + + return config; +} + +void render(GLFWwindow* window, const Config& config) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, config.texture1); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, config.texture2); + + config.shader.use(); + glBindVertexArray(config.VAO); + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.VAO); + glDeleteBuffers(1, &config.VAO); + glDeleteBuffers(1, &config.VBO); + glDeleteBuffers(1, &config.EBO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + auto window = create_window(); + + auto config = setup(); + + while(!glfwWindowShouldClose(window)) { + processInput(window); + render(window, config); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/03-textures/src/shader.cpp b/03-textures/src/shader.cpp new file mode 100644 index 0000000..98c8633 --- /dev/null +++ b/03-textures/src/shader.cpp @@ -0,0 +1,101 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} diff --git a/03-textures/src/shader.hpp b/03-textures/src/shader.hpp new file mode 100644 index 0000000..7f59481 --- /dev/null +++ b/03-textures/src/shader.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void cleanup(); +}; diff --git a/03-textures/src/stb_image.cpp b/03-textures/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/03-textures/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/03-textures/src/stb_image.h b/03-textures/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/03-textures/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/03-textures/tests/bad_shader.vs b/03-textures/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/03-textures/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/03-textures/tests/main.cpp b/03-textures/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/03-textures/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/03-textures/tests/meson.build b/03-textures/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/03-textures/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/03-textures/tests/shader_tests.cpp b/03-textures/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/03-textures/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/03-textures/wraps/fmt.wrap b/03-textures/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/03-textures/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/03-textures/wraps/fuc2.wrap b/03-textures/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/03-textures/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/03-textures/wraps/glfw.wrap b/03-textures/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/03-textures/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/04-transformations/.gitignore b/04-transformations/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/04-transformations/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/04-transformations/.vimrc_proj b/04-transformations/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/04-transformations/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/04-transformations/KHR/khrplatform.h b/04-transformations/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/04-transformations/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/04-transformations/LICENSE b/04-transformations/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/04-transformations/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/04-transformations/Makefile b/04-transformations/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/04-transformations/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/04-transformations/glad/glad.cpp b/04-transformations/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/04-transformations/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/04-transformations/glad/glad.h b/04-transformations/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/04-transformations/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/04-transformations/meson.build b/04-transformations/meson.build new file mode 100644 index 0000000..7cd585c --- /dev/null +++ b/04-transformations/meson.build @@ -0,0 +1,94 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/04-transformations/resources/textures/awesomeface.png b/04-transformations/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 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 Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/04-transformations/resources/textures/container.jpg b/04-transformations/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys 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[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/04-transformations/scripts/reset_build.ps1 b/04-transformations/scripts/reset_build.ps1 new file mode 100644 index 0000000..975852d --- /dev/null +++ b/04-transformations/scripts/reset_build.ps1 @@ -0,0 +1,7 @@ +mv .\subprojects\packagecache . +rm -recurse -force .\subprojects\,.\builddir\ +mkdir subprojects +mv .\packagecache .\subprojects\ +mkdir builddir +cp wraps\*.wrap subprojects\ +meson setup --default-library=static --prefer-static builddir diff --git a/04-transformations/scripts/reset_build.sh b/04-transformations/scripts/reset_build.sh new file mode 100644 index 0000000..89931e7 --- /dev/null +++ b/04-transformations/scripts/reset_build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +mv -f ./subprojects/packagecache . +rm -rf subprojects builddir +mkdir subprojects +mv -f packagecache ./subprojects/ && true +mkdir builddir +cp wraps/*.wrap subprojects/ +# on OSX you can't do this with static +meson setup --default-library=static --prefer-static builddir diff --git a/04-transformations/scripts/setup.ps1 b/04-transformations/scripts/setup.ps1 new file mode 100644 index 0000000..050d716 --- /dev/null +++ b/04-transformations/scripts/setup.ps1 @@ -0,0 +1,4 @@ +mkdir builddir +mkdir subprojects +cp wraps/*.wrap subprojects +meson setup -Ddefault_library=static builddir diff --git a/04-transformations/scripts/setup.sh b/04-transformations/scripts/setup.sh new file mode 100644 index 0000000..7881736 --- /dev/null +++ b/04-transformations/scripts/setup.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +set -ex + +mkdir subprojects +mkdir builddir +cp wraps/*.wrap subprojects/ +meson setup builddir diff --git a/04-transformations/scripts/watch_build.sh b/04-transformations/scripts/watch_build.sh new file mode 100644 index 0000000..44a5516 --- /dev/null +++ b/04-transformations/scripts/watch_build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +fswatch -o *.cpp | while read num +do echo ">>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/04-transformations/scripts/windows_setup.ps1 b/04-transformations/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/04-transformations/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/04-transformations/shaders/3.3.shader.fs b/04-transformations/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/04-transformations/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/04-transformations/shaders/3.3.shader.vs b/04-transformations/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/04-transformations/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/04-transformations/shaders/4.2.texture.fs b/04-transformations/shaders/4.2.texture.fs new file mode 100644 index 0000000..91591f1 --- /dev/null +++ b/04-transformations/shaders/4.2.texture.fs @@ -0,0 +1,13 @@ +#version 330 core + +out vec4 FragColor; + +in vec4 ourColor; +in vec2 TexCoord; + +uniform sampler2D texture1; + +void main() +{ + FragColor = texture(texture1, TexCoord); +} diff --git a/04-transformations/shaders/4.2.texture.vs b/04-transformations/shaders/4.2.texture.vs new file mode 100644 index 0000000..ab395c6 --- /dev/null +++ b/04-transformations/shaders/4.2.texture.vs @@ -0,0 +1,16 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec4 aColor; +layout (location = 2) in vec2 aTexCoord; + +out vec2 TexCoord; +out vec4 ourColor; + +uniform mat4 transform; + +void main() +{ + gl_Position = transform * vec4(aPos, 1.0f); + ourColor = aColor; + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/04-transformations/src/dbc.cpp b/04-transformations/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/04-transformations/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/04-transformations/src/dbc.hpp b/04-transformations/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/04-transformations/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/04-transformations/src/main.cpp b/04-transformations/src/main.cpp new file mode 100644 index 0000000..7f54712 --- /dev/null +++ b/04-transformations/src/main.cpp @@ -0,0 +1,264 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct BoxTest { + b2Body *walls[4]; + b2Body *body; +}; + +struct Config { + Shader shader; + unsigned int VAO = 0; + unsigned int VBO = 0; + unsigned int EBO = 0; + unsigned int texture1 = 0; +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + return window; +} + +void processInput(GLFWwindow *window, BoxTest &box) { + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + box.body->ApplyForceToCenter(force, true); + box.body->ApplyTorque(0.1f, true); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + Config config{{"shaders/4.2.texture.vs", "shaders/4.2.texture.fs"}}; + + float vertices[] = { + // positions // colors // texture coords + 0.1f, 0.1f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top right + 0.1f, -0.1f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom right + -0.1f, -0.1f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom left + -0.1f, 0.1f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // top left + }; + + unsigned int indices[] = { + 0, 1, 3, // first triangle + 1, 2, 3 // second triangle + }; + + unsigned int VBO = 0; + unsigned int VAO = 0; + unsigned int EBO = 0; + + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float))); + glEnableVertexAttribArray(2); + + config.texture1 = load_texture("resources/textures/awesomeface.png"); + + config.shader.use(); + config.shader.setInt("texture1", 0); + + config.VAO = VAO; + config.VBO = VBO; + config.EBO = EBO; + + return config; +} + +void render(GLFWwindow* window, const Config& config, BoxTest& box, b2World& world) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, config.texture1); + + glm::mat4 transform = glm::mat4(1.0f); + + // this is position + float time = glfwGetTime(); + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); + + // get position from box + b2Vec2 position = box.body->GetPosition(); + float angle = box.body->GetAngle(); + + transform = glm::translate(transform, glm::vec3(position.x, position.y, 0.0f)); + + // this is rotation + transform = glm::rotate(transform, angle, glm::vec3(0.0f, 0.0f, 1.0f)); + + config.shader.use(); + unsigned int transformLoc = glGetUniformLocation(config.shader.ID, "transform"); + glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(transform)); + + glBindVertexArray(config.VAO); + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.VAO); + glDeleteBuffers(1, &config.VAO); + glDeleteBuffers(1, &config.VBO); + glDeleteBuffers(1, &config.EBO); + config.shader.cleanup(); +} + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99f, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.0f); + box.body = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.body->CreateFixture(&fixtureDef); + + return box; +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + + auto config = setup(); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box); + render(window, config, box, world); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/04-transformations/src/shader.cpp b/04-transformations/src/shader.cpp new file mode 100644 index 0000000..98c8633 --- /dev/null +++ b/04-transformations/src/shader.cpp @@ -0,0 +1,101 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} diff --git a/04-transformations/src/shader.hpp b/04-transformations/src/shader.hpp new file mode 100644 index 0000000..7f59481 --- /dev/null +++ b/04-transformations/src/shader.hpp @@ -0,0 +1,20 @@ +#pragma once + +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void cleanup(); +}; diff --git a/04-transformations/src/stb_image.cpp b/04-transformations/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/04-transformations/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/04-transformations/src/stb_image.h b/04-transformations/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/04-transformations/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/04-transformations/tests/bad_shader.vs b/04-transformations/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/04-transformations/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/04-transformations/tests/main.cpp b/04-transformations/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/04-transformations/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/04-transformations/tests/meson.build b/04-transformations/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/04-transformations/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/04-transformations/tests/shader_tests.cpp b/04-transformations/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/04-transformations/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/04-transformations/wraps/box2d.wrap b/04-transformations/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/04-transformations/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/04-transformations/wraps/fmt.wrap b/04-transformations/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/04-transformations/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/04-transformations/wraps/fuc2.wrap b/04-transformations/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/04-transformations/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/04-transformations/wraps/glfw.wrap b/04-transformations/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/04-transformations/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/04-transformations/wraps/glm.wrap b/04-transformations/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/04-transformations/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep diff --git a/05-coordinate_systems/.gitignore b/05-coordinate_systems/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/05-coordinate_systems/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/05-coordinate_systems/.vimrc_proj b/05-coordinate_systems/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/05-coordinate_systems/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/05-coordinate_systems/KHR/khrplatform.h b/05-coordinate_systems/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/05-coordinate_systems/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/05-coordinate_systems/LICENSE b/05-coordinate_systems/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/05-coordinate_systems/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/05-coordinate_systems/Makefile b/05-coordinate_systems/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/05-coordinate_systems/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/05-coordinate_systems/glad/glad.cpp b/05-coordinate_systems/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/05-coordinate_systems/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/05-coordinate_systems/glad/glad.h b/05-coordinate_systems/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/05-coordinate_systems/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/05-coordinate_systems/meson.build b/05-coordinate_systems/meson.build new file mode 100644 index 0000000..084c32b --- /dev/null +++ b/05-coordinate_systems/meson.build @@ -0,0 +1,95 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', + 'src/physics.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/05-coordinate_systems/resources/textures/awesomeface.png b/05-coordinate_systems/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 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 Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/05-coordinate_systems/resources/textures/container.jpg b/05-coordinate_systems/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys zy=$e?5?NMvgtf4$5v)JkAN1@PxaL%LlnT7H-|AYMo%mpM)Q)68A_X{^8$_39JBck> z>{};}sE*Ev8lafSk{>wTeEVG3Uq~g_8S_b38 zvl%)q`70GVU2PjNbXQm%t4aDk%~|`W93BI6JzW}$+g#35Mq$q`zOV6lYf>0oG$-$$ zx_u~OOOtMfwucPa+af>urgUk)`mUnM zX7MEU%@||KGS8m@HZllzCas2VY*%#_70^w{w$%FVd=)siSwZuxogN!iHR*n&TNFL* zZK0VNSY7dXW}Uqw?BG0t)@(^2@7{_~M&JatXZ`K0cO@Cdqq#11-?t@w*AB+2YsR1S z7Cu@s-llnWxeZwpYePG@y2Cij!`V8l_>^*BAAfy}Q7O|ZFgB7L`)N8ktO%wv-L=b+ za6Hhm*Fv_+9nL@D942ASOk@Vl@KJmOgmE%7$_>!LvL*zTp36b|l`EhwW0K(Q4Qg(w zN|9*8sXOfUu+O-Avx5KVl7Y);ZwFKk$9y8?2^lXHxa5Q!O8kpLdC_Hwr0U(Y%GG3L z(@SQQ^BShzAL24w2BzP1y{%`T-z=bA#ZKrRJO&7J%wCM%gwe|mFjp9lDc@RJS~>7^sY0?bcWWx5;^=t4s!l)8>b!+@Coy50NhLw){%*PV)>9|_s)9*r@~P2hXXr%yTa=(7TVc!@ zS)cK`QPE#tT;{x#D&3N_cc)E&mW&O2{d3&>zO?u9EQCpogy93i$!VFzwyG0mu3gt521i&i}ds;HE;H2zTZZbYO%so_VfbrwyIJ?YLXSoK#I5z5^)#iv=D`#7)l zMMXOmZKnuh1aX`)ocEX;4mz?nM=Z8uZ65K8iOsMvsXP?R^gkY)uYUJKb7_dt$?*YA zja|NHud|f-M5m&SQ~xo3abIrp2)cvk$3U8)pC|*e*=G*Ns)=Atk@oP6Mvhamd-E|+#!NAO z^LDUI(C4*^%tIXnoq%iOd;lwW$JLT-?boH%;?)agBTE}u^ba%+v4=21pD61ezVbrm zp@T0#cqv8?v!~ZdtH4>V-{`+2fgP_NXMGH`q;{rkc^^FWE-G@$pC4@*(C#K3+nw*< zlN&P5&&zP$Kk!mr+#Fb0kwY_@1W51Lg+EHk+Sg^z9IEPft#HNL6FW4zJ~G^-K&`DTOHR?&3sli{w4epCp^AI@hezw>pMv8i)H;{Yn3u zECc7_Sck`q6iec(6jKKq$G{TxhGas&c~Iemii+V7j}Jo)LN0pslhr(z{VkWoger!B z60^G$f~rW-HeBe=tKlRbQPPH`1pQm9jUO26j^0$?uP*4P$oTB4L^@W#?iSJTaV?%S zo5zQ%kaFnrM`?AzF#I*YeitvPj-@f8Olx7uCq%J512I!+@9LFn-o4qWIbu8-GZ-82 zD=6A7`|+B)D0Fyzo221e;o5r>@sIYy_=va`S`lpRDteQB`SO|1Cfh9uS99+t73Fy> zS>bta46zsuA5=J9DCpAa8P$k|IY)|A`Ay59k+-1^Fov-E5Qem!^LxV2}-sz)go}n zijKR!c$d_-4c$wut^S+~s7aC~e@)JL(=vVELe)>>ftg(&KVzD~&Gy568q4tBkUoJh z*j?nV9dlA|p7-kEtV%-Gpg^MI)A#^#IbQHi84I&L9b%D;nc0gsM>+g!$M z48uG3lb7-OHC`92(shP2KRpKCU#wV4OY1?cp*_orcBv|x#-Wqf!wrnLi`I9foT-LQ zMTc&Fl^RZQbM)A77g<3^F5^NN)$=X*_p)BNA^p_AAJoC0s8hfn%8&;u2hZn8f_KYE zna89#OWMmqN0}Smht)}GJk+8}{eXAS-&3>nylNk*QmtJqyP6GKN^5@K@diDh5^v7h za;D+NO^fcV*E1iD7uQHS-lD$Xj()24_te&aS(n_ZXL?{RVSmZo(wu!>(ZLedGNC;#lkX6`_N`{*-~ml{ zO@DWu{UhdL;`<%E&kl{>jpZ9O$A2mGpU?vbh|cXpq5bEQunkPZ=h{nx4YtNjESe9q zLOzd#&9}Snxl8TD)C^g9yS_zbTH-u+ke1TM4FP}iTlFy1CtxCH zR|FER?S^)C!LENa90~|D zrVNJsvrf3HmZc+HU)dOAp8B(~p9OSWot$j+;Al5zZL8a$9V|c$+UB_ePT)TqfCH3|-BUMf}tf02*?FCb%ai(txft6O*-*o7EMkNsNRiN!1nk zZ#V^qf9F$hwbnO4qE%RR9Zt-3f0tKqux9#CcwLkO`UJ1z>2O8&H#b1&4u_$gT$L=* zmY5!#2&rSMgZe!yFffK0ykf)#uEA}7R`V~->VtOW|EXC$n8Q!Jjw|en38sdVL=JOx zayGJqgM$msP|&#axB5si1YJ-j1t&Dx$#&q5d9{A zvi(70)(Y0@PZ@sMmP3DEPu3B~2@SO4|DELS{#tz`Cm787yl}#K{-1fQjgvgV$r(IB zPG%`+g^x*uzZMBNVNWCgt&zc`2JqR~fD{Mt3|h;B3Gxe*^g8+vM(_j=+Kd0eh@4p%W5B{&M0zkSsV0JW2Ib16zH>5S{Usfs%jj>%n*^n{Q`_CK#k^eFW0fj$v^`{uR zf2QI|9v9_+fWc9Q4%aY?3G$D2a876-ni4$lPBQ9Be`^cR*44?)`5!1;C(tk-@n@e@ z*2C1UeS!n)AhC2qJE_8va92w-##I0S^u3&aZ}WsdnK2j)McvVs3B3H@?mw2BtHVET z7AMO8Cq@%x`_CH+uB8K7-_rIUT%<6#gM&Wkp`eaZ)7QNAd&|QAjs6ESft{19x4Z+w z_P3_Ues*5%HyZ3Yp7l=ydk`dWhr6Qx1H0jG^gr2&tZWrQgM8P&DVO4B{R*mo2w)LF z%L$3mH38bm8N3yv;D6tv2pz!9?BB4&RwtX^zu}3%A-4Nh_LDVr5z`QOuLY;G-1-Up z^BzfY0)rM|CtTDgIn0EHoa8b5z-7$7fLSVuKM%+x0O1Bf&;#cjX!myNadYZ%bLw$( z>Tv_^5vLwErye(_9yg~RH>Vyqrye(_9yg~RH>Vyq|LRn8>Tz@8^mFQQbLw$(>Tz@G zadYZ%bLw$(>Tz@GadYZ%bLw$(>Tz@GadYZ%bLw$(>Tz@GadYZ%bLw$(>Tz@GadYZ% zbLw$(>Tz@GadYZ%bLw$(>Tz@Gar1xKB=++{Nsqm+j?N6(Ayp!npU>nC%#AUzYha*wEmY7)l zyf7z6K2J+$J^@~SK0sQ|6O8C>4@Wau!9lBT8J4d#^(;&XYZ(?J5lwzgXGORjLe1M1 zuIH_#5A(K%Nm#SU$udcMN_sjvJHpYHOrDMoNR*_f49iL7k|2yh^RY0Uu%PW_SWY5Y zG8t>?fHAyX;Y=dDLOd{j0RbjaQCPj*!D#8N7iV6xMO8hFqLJH!FLh^!2A_Ag9O5zHN zV*H9Kzssm2QD{prI6I~cSPL%#VJ)ekASxj!CLyROprWiSC?FsqB(9_=EHA;&FDxM< zBqaK~>`zYtONak=?OMYmZJb;kEkTtd94&3(e7Bw9wk%A4`Yw55^seb-4VPgNI%!H$ z(G?E5Ab`F_APV!D2_AlN9)3}M@M9C;Cntm@xcCJn`T2jcg5?l4UjN4W`->F+UA0!M<6 z79QXW#@_){L2OH;al;0fx!}TNpJ{0uX#e#qlK92(i#K*+WF}81&+0YFcSo^Si$OFSDCl zk+0G-$}3u02L|Wnw|5Y?J-xgi1wW2@9i5q#U0GHA{zKd6q2Yzar60R{6aW~pA5z z4eEY!F^pYUZ@NT;LkSGsZ@@|Tp!D2%+KZPii;9U$NUEr+sb4k3NDH^IwL{!SySaOS z;yert0wsF!GV&EDRZ41FdIl(3S$PF0-P`7OEv=x4y?y-ygP@!IHWm8(`G44r6SZjku_SEP)LkhLKpvvxI=L9deB*mrz;+!?Vp#BJ}x+O zDmk{K;SVpuL}~DsQ=}~VpI#;m+x_Vd#P>zl zw4l#r{I1%(4$CB_qa@R~ZxxY^%d>Z;?5^lBfX2JQdk_)Wt*&zG(%4=>5Wb?uqdJ{J z1T6Quef-`tB(G=dEVcV%xAVzYGSv6FgBn$e*b0@Ib?&}TrAVadI#3mjVYv*(C!|#B zrP}I8WQmpwm#(+E?h~-Qos_QvgI#h|rGH$HhClBMCDDCjq2-{EN^Ve|R1w%Cb!c8# z>dH?&S?xelI;cLlQbWI5Bids5;!&5yeVNj-Fjrvv+k?-Q;(Dz@*6DJzuMC#txKjD3 zJr5$Jt%YCoU3`BvW@nTS)hZPf*r>1EYrUH4>ygEMHTx1B$>W^a?mVq?@6o-kk;KYh zTVoLKzZte?QoqjHB6yC^uYacK1$JflIwMWIv zm^{kXwKO1~I>YmbDR^8xq^||e>fAHz`7I+j>ajIKXGAY+Z~l>0Kkh^ODG~U6mh&&v zXl}uh?>oVN#C0VKoYNcD6^N!=r`J2v!Vkvw$;{e4Q+4yQhqVo`U6|ZV5M#%~-F#G|%<4baUMaH;G*e36ZMVo^Ced#XY0v`Ak3vb zka*k5qvOoQ@2fb?t{={E`FfCLgynEMhrEcRS$(K3!jdwuW;hyd0CRg;D0MEjxAo%Z zW3B-)ELcOFWb@I4^H*P0(b=3}@m}>B zgc60efrV?^1xG2%q%ZM$^W0gwUm{t@cGze~V|>I-XZW~v`@|otid?Ewo_ayJ@kw5? zhD98HVa)eyN{G;_Og;!l{_JE(X-a#XPJ2{2+5EeNOs*wX zYtzS`y~fd2*)@I76yn~FOS<&WwyQ_waeQM_8g$(<;~nT3JoD+ZHOa$%_4`kyHq}}C z-nq8FQ32?PMzKC}3?Ui_Z8t8l*u`xz_NQCC?N8vdIp<=oDc$gb{6SPmSYej6*(LkM zN>AsxPaLM-beh7==MVrwybDV#H+J?6o8UVwSdMEuTi{t{I=6;Gz~%awdt2(p*X+12 z&K$Vo-r0=%dTuCzYY9BqTdvJOD52Ulh3N)QDj%1LmDNhd`fsW2pDy4z$+iVsENSG5 zL+i8zg8D68KDtL{TV8^PXa;MOk#0{176+=dU9BA(m)_5cylF^%%_4^*KPOVzP~Pae z&{cI8N!6(;WQmBU<#8(INW%ph+S1WGitL*!v&U#jUGz`$VIg&wpWUk(nAJd2% zDE)AWb2t5iiwWoB)R%EI6mhStvSin)!!4(pV&C#&PpJ&hST_i>&E3?I@FuilP7Wez z&W3x=P)B(aMh6Ot6G99829Bh;oH%qthsAsZ9Y|ihzELqpESj8s^`Kt;LEAMed@jUv z$OqB2$DK|YG!@U?x~(?6q%P}iS>1uBWHlRxKDNdEcBe+KW<(=&P+EWBhF;6_syi=N zsb~013!fI--O7*PW?p`6>7D($ws4R}hl01+hhRF~I*lFy&F^Npbe-?|tpZsGziaF7 zMI|+)J_pE`<;n@Q^xn3*J+=^)CPJgvOB5JSFDZb-W)`JLRcIEcUbyGkmMbra=rbpS zOZdkfXeC8T%ck}WbSR`R%tkY*SFzn&7oFiMXXZz2j@`Y)8HKuW+3JjLXW5TuaUYe9 zBKKiea7TdjFL5H09y1|DnXQD~RTS#OygBoN8@gV6By5*;UyjFVyv7akx}wsf85G8N zR^U-~{-zHOexI*qPG(YQw5ha8vUAJrq^pJ(hv$(!BzaD?-yY6RP9qe(g6X*8nfu8i zEZKRei?nDqzx7e8V$-=-Rx)8V=gl(3B8)cDus43_8m8okZ<*>#FS01?!%}Q7SlW-? z9u&p;EMBmC6&D)8C2AVV5gqE+%BEA#bo;y-QM6k&Y9)X|~4o`=Exl6m##pp!TVw~6!S7zx>R4A%9CYEKMXYhKuX~`v5 z;Xa|au}Kcc^EqO-z@((_1Q9Z6xru?g%Aw`cwz-dK`^#UM$^~>p2~Rf*B{$E1f%&sIbU{?%osuXn{s-C3OZBgN`x{jsQgWISg?u88zGzL;HKxWUQYwA(ne`PAJK zF2!5#491;r`^DQl%?O*(pJ8YhDbnDe3)Q2xv710+pZn5tDdlj}p4<=H8S$zt^IW3a ze)H4Y$qRcagQFbq=vQ>Rsv6v`%7!y`47rM)kjA~dywG7hj;VF$v}-pK>ol+JhdLrc z4!ZIzM4tHg^#{-5JWOnol?#!KdGh?K_l5-_yo0~=N257%qR6X{(sS{shps-#U)%V2N@KOF<7r;WTsQ`L>iBZ%jrt!W+HU!< z^(eCI@7=e|n=PxA(2F!Bm0c=)Q@yZr^n%0Muf#j0?#*mPXcWrp^b0T3+kB}) zu#4H>#iK(G1>7+52TaBId`FbvE(&6m58hV+nGkY1!XYnl~?o>U{Q^pN9qx$~%N$AKqI=Y>i z%BX2GrZ5Syd96=ugS9P5K&7qlTUm>y`W`y?jsEN{o-t2gjcsawa~aWPbX9xH*3op^o^NranfgTZmAOTplDkUmM+P&nQk-1 z@q9co96T@XXxJDqnnjbsugp zgyw#1c9TS$Vce&DRe?|dH%yR7Wb`G@)P+)^z2#SD7Q(b8naz40zvdrx5;G|Lc>eiZ zHWz!O_RF|7X#)+GByDEXNza{WhVEMB>A`|q)JNZpt8PDN95JwpPdrqc*7f?R^ZDsx zVwSX}TQszbZV$}wh>J@2mcrz%$KI$=f72dh)TMM%X=2Weka7sU9qrl>6LZ(HZ(sXj zj=km6!7{mf!5O1+c}K~MOW~K-m+lC1$jw@1JytdBGJg1^c?#;p z<~n)rfTYk^y;jx7Mo#*nv{kj0{rGI68y9-~;yJj@o`*v7iQWPNX%`rl-VTft;S|=2 z;v-@Mj{*6-RLfDnZ}*~y_q__*Otd)1j8GfF!wLS2x^r7b%h8oG1}cPQK0%9YnR#i> z`uBaZ0tPDHYI&Lr5kqzi6xKQ^zy-%8m&Iqu$94u~-NCCqV;CTDFpTSX1)HvyZUK*% zCr^DpEA2_L?1ZmN&KA|ubUBg!muTEH3p3c%LiGZH9M31e8y)^k!g=8@M?h>7DIg#D2y=sHomq{lWOoisx{2kyh_oPT*I4zX|_EE&utO18HaUZ`{CKOBff`HlsjqfHL?BpU$*?2)bB8%&ScEgiaSlNBlQFz2$%W!D>L ztn_`lF1#!7I~aCcQ5#vyPUw6Jo6sWPd%E?3>9Lofy%qMQNQp1m$u`$lv2_<6YqQFW zsHS%eV`#!9ozv5{1eS@XulLi35Jx?}o3mjcOvWCJr@8rNfeowGpASxcW-Z6V|QEjSyTfw%-f`ea~ky&8z{{T%uvcEVE z3r{Wym|r+oRLI_bABRs(O3}e@c1_YyDwA>88;&AN7D_Ngduc<>T_kvMpvw^TGwb>Y z5^1u%O%*jkY1NHp9cE*oCe)))1-0VzS>^l*9)^;YULWBe+Du{otNm=pS>;sWb5^t{ zQkDnBA&5rh#m(b~-z1FzzaCYEkr*F!RWDu7+wZ3Z^)c%^4ydTaDe_fBa#dZc=7SoQ z#E$nDYbAmD2QT?MNX1_2se14FKKf$BeL#B9tlu>G8mdKgUoKf|7Iq4xon(?0V!r}; zp=o8aS3cURt}j2M&$78g>WkMs6*@&vm+NV1p!cCgdOfNyb8qxcTkh2# z;Z;R6w9(YiIbFizLrB{4sIsvK1s`YYPWPAH9Q!FgJzaXzUFg_-Q#y;Y87KwUwxMXn z`Ei%o9B1A7)e7$c#B=PgFRQOvB?%Z0aG_xUk?Z}K)hKJV7A-(8WipD_ObS01w~%}B&EWmW`~ z${ALvu=zyNn}7nP39uKr? z#0Ti(CggwtwYvkr%GwHbL-;|XhE$}We@M~x^s$iXD@}E0QSlRxQ{mL+qOTOIr6?&X zTWhp?Q$e+yfIztm+g<{9n(sgXI86`tMTAK!6GoD=rquXeRLhT(>1Q~eXsf2Co|;$| zQ7TGrF_qYd3W@eljlMi6YV57EsM51-rr_wpO@IHo!=afuUr=q{AxG@w29{Z3(&1?i%quo=te#_@YLdkfaz5)M5S zME$DJaTFCg<}5Y}df2FFJgGj*M~9~2b}M6cw{gP-1e!?Vlzl2~A5d}HS>7sqI*FbV zH#=eQXh^-j*KTOCnX5MHiP=he9;as~N{3h|V~&?e6k(8o?;gWm*XO&0)4I&fWNxSC zI(cGxd^Uy&XVxJG85*l=w_CBl8T_(UP6x_q;!dY$x|xzWuMa-@<-@gtT?C_4$Q0#m}XVckm2 zm&GJn3^&Mtn5vbiVm@KjPTk%H=G@Ym0Ag!>;XEmAmUA|KtD3f-4yMDfxG5qvwF^^5 zp$(9*8+T~hSo}{JAtJ3L3_E-mJ>)>Qd!oW2w1}SzN6X1>bGnd z2A=QN6BN~m=gy+w6zfqwUcsI!ow7$ICKF6t7a_pD?KxFhA!ltqo7WOB0zB!J`u_l) z>6Iy$E77!sr92eWcw90`H<)zVh)H5M6Ki;LU&H62ysVFw#lz3E7 zPQj8`u-I+y8{XTkuAHax#)7dm<>oFCfTUJp>K9R~CyoiLP}NqXbfi&JK?))v8&sWa zp@)aJi!RQO#)`AQfaexwQ#2e&lvSKA5n?TmT=0-YFd@T zU8ln1mDS!hlmgrBYbht$#+7P+@D#aT8mnn;`Fo&u5Cuc(=UA(HuL34j%7 zcTnM>TmyTHi98Qu#Y|bCaWs*4iz8(kze0KPvZk*-RpL;>Ci&bV6q1q!h`BITx4r?_ zPyr)={rI*TQU?kY?t8zqRMEEeos=nY4xHr)Cv~c(t;Zq7@Xh;_!dnEyppkArb+r4q zOSq1dy0O*sqfPK{Q)xYQN_bsF5Xls@F?o$8q+OJ4WZnS>SNQT(QbCER;9zj6rnelX zo$8tdLjxCfl9`)*jn3;Z(@s>dk}2feED8`XoW)&H9UOxwP}h9M*%{3XhmlF#Tl}Vn ziN7wC&NSe=TB$`ga9T+uo}(n;(NhH8$kbCad1?z-{*v9n`nb`xl)*HiIf9U&Kod(E zPOsur6rwt8xrIX!u?pBzxC*4Ugvs}DFv}8n(xqoBQgNsdb^90dZ4L{EvtGhMgfghU zg5@4?fIN$O{ zsllDQ(M})dTQXvh#ay{l4wjml#+^+SK}&tB72VrT+;jP20g0_AG;v%iEd6NAG+t^x z7lzR@qizC@pgzLEY=kzJE!&M8nH@EM=T3A}O-5=;vo1f1i3u?^8|uPg-p#+^=S17#9=B`s@x#p5E?=oVlcq70xU|l6WDk8G3+6F*24g)tj3Ws4sENi(mu-YezC# zg>c043>5SwD=<7dSa&L@H1$K??QIwv4p>`t(`vp@;ZQ4cjtN&!6(Py=OXYi!EVcY5|5MuBWT1BH)5SEIfO0@n<}0s>}o* z4P(eTR)eS&)wPt^3=M%%PJf!u<<$XGDI@(F7Lb%IOMt|Eh1b1-X8B>X#N$ocYFe;O z8oVO~z`Adlu)IU5nb>6o$Ejt)V2ZtxmX#?K`6iN$EY0Ms4Yh&N_7}N4Ce*hP;SvQe z2@Na6Xz%5}RUVph_f8Ey71b;w`LJ;cWkf4;HpqFhl~^s zkLIDO9$q7d)sSm&yhJV5Xx!M5bM83%Lh5zod2*+0E+_bT+e7Ak&XHlB_ExTgH;3BjyB! z_B+DR$sik*$gPEyj=t!=mmF}T#wMFm^q|3{1!gHxJyX)u)V)Md-areRS$&t&ijt8N zN#vSl%DJv=52*PoGEz?Brvt^PF$y-8!)StVe=(==ZYfnzo1th*LhXOFPka3~zZJGTAX8IH{1&>W`Q}qKCv!zm$8!;Dc@hFa9vbm3 z5NgQ#g$i`Il{~nuOl|JPV3JCpeVSbzXGxZ@q+G_bOeY0n(WvPD%% zJb_}8qA9B5hQJj&;uf--0q9T!h@$m<`t2^S{a_=4i(HZ=i_DHi&L06B*MYAj-=j-$$SS%mEL&SXYDM{w5G z_TuC@AR0;C=_aQwG<4L|6D(mtV9TYx#gm!_obKsO49^u6Lq!uR7L~ln?Q7hNe%^SR z@*5o#5;9AO!H!7I)=AzNSf8>1u@>#cEjb35S|*L3qpBDKW*HTB6|bN&HOi^m1m#Ab z9tJn9V5E6ak9B8R^P~0ZYP4eAFv;{NR!Oi-PLU*%H6W01yhNRTzT66KfGN0e^pBkh zH=QXhr>?3;DBw}9S;Mgpvm?faL{z$<5h(^;U<(Z0(5XpdR*uEa7ooAXoiBim1 zNAVr)^qzUOkyKhp29}v`3kgGoGRCB&5x8OA`v=|Im2pIxb*8}^DWfz|Ghuj>SjGiB z+UfR;M4NKRP!UZnxTvC;VxdIY?=S@J)ce-4{JFBDI9Id?tP6uElMULwT2xI8RRzbo zS8!8t?AMi2%vQr-8dT6xVszNtwGbzt1tTmKJBYGwTMa+pYgaI-YmfMvz3qQvKQ1?Q@i#54o8;(nfa*NBQ` zhCv3K;lL=c`siR0I!hsGmOE_)cPY2S?Q=!xr;}^}+e&(BS@2p&=ZckI&oaE}GAk(} zX*_MMxaO>D$ZUZ$l*6k(o8dIeJv4E~$S$$Q05(6CymDaSNyr3JfpF?MsKPC8k`Y7( zC0zlv$*}|wIbaPpq$pEeWg^ExRYW97p_VxpagT9Q5c_*`TCuHnU|~)b0xDcCNL2;X zVGX$4S}}gd+sa9&gapzn6R1k;5!qu`m4Y}IyA!(FZZ`Ju^rISKQ5Bsql&6XpSv=~8 zQYT`!3vt+e9Px6h+8|TrN$BP!)QP4=QH15}IINhaEhr1+sVL19MXn5oQ?7t&d;v*& znWd4A+J4%_Zz>Wf)za7C9V@}`tVm&t7F^4U)cIQnNYDH5sb6`51_U2??sq+orsl(d z^*Z(Im>fE2bkhvkvxt=%BArmH#`?FLr_OoGQCnRs$wfhhs*?pBF3A{05IvPh1fJyF zop?2}N?AZkMFDQ*#|o9kfvm}ws4)CCI=Hat?<~R>DuGR}W7~^bc23$%wm?qGw_m~^ zAkkMZQSs-)BCCrJ#h{{U+K@?w>M;07M8Cx@Z{f)6v^$a#oM>6POoCN4|I;kLizX4a zi=mD3;akha%eoL${{W&>jV<2Xgu6Ce2L(-=*oi4MPn6w1IL;$oTRkzTg=pBsO~{O; zGRJ=2%koWC&YBFa*cvJMuMKP|s;OW=vd8AYWEUpVn-C7Z3&SKTii>lFI`ns_S(m5S z%?34>>7PKR5sF^3)gL&l$y6{EcMc# zR-HVg!!hhFX>kge1ua!PjDn_?sS8A|l6Kx1E{~vLp|QUsl8cP7&9a|g(uUx%nYAMY z`hK`odgdO2<_?YKN}Mkir8RW*ZzX13$K#LmRg}!*Y1dVdTF!^D;OfgYMalw!pk3Zx z<0~muCv!eT5n$LgL{}#eU>OarY=y0-vu_l({F6*~BqwDit1{z3g}4y~b&ff=5!n03 zxwkBrfi&x_1mJ6g2{ta<=a90~P|#6Rtlh!@%n%cQ5^c{daaUzCiL7|e2SE9oF4JL> zw1?#lZAwgnHIAe!??t;d+KNR5InxlRs?Aa~kv%kP zV6jXHZ+PzUw-zM>O(X?G(ASfqs$7waLMt1}o}!r;FzlZ*9*d{n#LH0D2o&(0HI}Om z4Oo1nDDo+aXqanZ?*ng-hbyYCgwi`6!A&J*7|;@qwUn|eK9?SPc-sCPbq+|TE)fd# zrG_ojs+#Hu>!_zF&7nj-@pd4u@j7v^^iqP^0+X~@B~3md^3{_us>BG1sv73RJV>a>4x;>Drs?wYKy$PZj)^w7fTZV08u}88#e?RaW>dg90Mm-zA=Gek~P{n zsv``#s8ywruYX|!n=XwqDWtYipqlEclCuY67(yh0^pUN1_w?<4Q7%m=P$GtGnMnAR zZEaNKLls34NH;dp$IOc4A8#4BP}5ekC%nd(Gi0)0_|6mZF(9OA1S-nmnYS_4HzB=hrV1&jAf>#qpLM4Dk)J}(TiDIYg*tDsJJ%q;&r$J z;+||BI8aN4U=Q67ZPvv#-u_L%3 zp4<;^!|5(AIw(b-Ta%{_HC*`+lp^|vL!9yI2YcL?htSxb_hlA%|l~4hu@WfI# z5Wt$Qjz*14az{I}Ni%HUOp+^M3sVOilHbEZQYAIp;D|a`D8;f7t z#LIpcPPEI<6GIhLfoF}7f!Ig}z5waQ0)ZWLr$`2;)nRQVRVW-k~T*PT*fh%xotX5@t+siSmahFvj_!7PE zrx9jXfwu=;UoU4;Xu9Jx71Lu&D@^jo5=!wR=mnJ*y@!Y<+%auJBDAJqRJwXblP_Uu zzzHES>DQ`k}U)Yrr(pC zBg(f_0`5T@EpGn+nd61Xtu~H}Qlau|FRYH!$<-{uKqO)j*vQ@8;}b3I3r z`g?%IHFGr?r&kK)vdr%3-|9~v!6N|Aq`lyC+<8r z{HUYjSdKfLaY?a^$2u6&^cYS(@={%D5n^QpUe30hHAK|zaA(9`C89YVzM zQB%tmLmj(Jko)QZ?`0SI_&-t!Q1hY%ECE&hni7TcD`8bNmzCYts-HFsN`beUCSPVWhCHvije|Y%vjVu;kTZOC|zjj?OsM1 zZv(B5N_wA{qQqksj&)n8ael_##|Abxsdo@~P(k};BLhHgH$dkF%(8h_`8qb8ZGASW zJTYP45Ty4gkx7gb3yLZ_w^drW?@o-&Y*;Ni5~ky@EP1CLGgk?eVX~5V%OwsiMOhko zzv#YNnOfzxD=TUTek^Tzg(D*x6>BoM%{i)@6UC#Ju_}tCdQySr0Wpp(s&=nn7V0n>I{2fn!{Gv@uN6U12H+RD_>U9D zb)Gb#DV!;alc(5DXX-ysvfeL=91jM@F-$uQ#&N`qN@-y(W|BaJuHqFtTyf6%VFZn| z(~YF83FA*v;dL}rlEW-pO*1Ug`ATdEir@lmdv@aqcudlQ$pVo0ZUFUJk1ti#MoJfw zNqozK!X$D9zdk-zK%|HSu7nD@77Hn-aLlg36@AquwAxRzjH%%m(!?b|b&3#j{!E6i z70Z(~D2bq_#OjZewCb2#@885CVC z6Q>lg?h#Eq(4}5X!G2;$sk=o_NM@CMSp=}$538QJSkp|hk`+%m<169Sn2sGJR99M8 zS=FPAkSqYbm;NQhExe!%QIe7l+Ed_}P9zzMPc533Y&7|DNpWjb!*EB^IbBBz^a-FS z;EHj$*&qWCqNvzp*2CWHb=OmVFH6{AwwYT%(YEyINqP>XU>J0D4VWvjDmij=6iVA_ zYN?<*k;;*@Mkn(aoeJD=w>4PstAN{EvTqd%XY1|}lDch}FnWAl>iUacjnRCyK0h5^ z$RYsR69hu-?(SgZ=udARdoC++9RO4JXzs}4G+D5$B5JG)FwapVRs57k52bepa9yh4 zd)D#(JT`gF3K2-yMhA^HLz5n&mn4Kh&tKw?#r`En`#q4W?_O{n}RkT)WSNc5-MaamyulP z!pE__#~0fxQKWYy>54L5iLm*pa9m;Lh2)Z}7Q?Hi7O+sQQy@Ba)NmiaE5SZgFWjcc z3!~HOHlgt>Qid3!A!yAdGoY{x>xay&*6=z4KAs16EfK1EK6H7!3xJv=IeRb7OOSB% zRSdt&>8FT2i5I7d`}|4JazI;yRRP;*#L#^{QkF_;m8Xof?Il18hW8PxI}e3|@j!cK zG>o+=FepI5a)n>@TMMXqW~iq$bml$d-C$|d_u~&PRab4e6cJ|}1>nk*p=BjvM}ec8 zRz?E;I-O4pZC%G2NpRE%rz%{w^jHQTh(%O{*6*dPqgclDh=JXiblrObJVz?!$BHS| zkTio!91|)ebkJ6$UT}G-@XVMzd8q-m&hu}O%1wk|HHD9` zcH-iwZYd6lGJ0rNtvE$pBzSZ&7MWD1oU!P~%)55>U%$hMaTK@-srg4BRN;8#B-P2~ z)P=6u93xPRhsgV{<9qmVx8Lx^Xfp~1qhfhht{R#*d4q{$0!Wrz%Wfz;qrql4zB_1_%=v09?QK@_)Bp!O1NNupjEG_Zn?iO(Js@sjUysgXj zPc+jQXjg!%k}DC|bnrty{`LiUE_#s>frYS-ixxLY7T^(DB~H{0|=_*3_Y@gwwiU2{g)~#CLa&*@uaBgt!aTkeqGEJIfpN`H9Vy$DgOXNBE+`bt6*54+rw=- zR4D;ElS&HgKjpBZ79H+HOaz1N1@i7bu>57!omBHj!Z4uvx{DOU=&@Mik&F#VQ47T5 zaNH4%fIki>3mU4gq{Pv{8G0$Pq9u#Zo|=$hamq;A3~JI!HSyZ%!jh<`(3~-#-wx>o zUVO%CsH!TOk1Jtsd`lNq1({X+;S@oL1}5i?)WURVc3_Q z2zPzWzqfES)7fng8d0al7#fdFOw|~L8X*rP3oA_OKp_09fKN3dyaqyXf*nH2<~|{Mg7h+i_P?yNyc*C=#^!Tc>e&>Vz}Nz8~*^x-M&0f(J*PJ6AG;O z4iOx=CRmo8VV>0uHAR@8cB)GgyTlJ?DyIgxss_9iAar*(=KP6OPl#olLP|>dH}fiK z%9Bk~O(8d@l|OkIez0stpm7doXw&G@bwl*@O`YEB9R8Yvx0$T-GMgQyrTDNSfi z1g%4egdt==#e91(Hrx*eHg`#K6q*ZMHd06;fo!iqPMIQFuPlk&$u&W}z!Ac`ZS@}x zELoLdT0{o=;(%x|db-M)!qfSXM70WJa6Zc|iTHQZ~}D;#D6U!Go*NW=v9o zoX|Xlh94Flr63YV1afWy_ZGM(+rl&~9}O6p6e;wVGOti`Z&xu~ctZteQARtN@hZBg zl0vnWaaUplA#iq?B$I9aJWG0#0(9`J+mR-C(FE&+G?cw>%rx=Fk<%?q1~?!d>I8BK zU%P@^QdG$4qQ_GTrG+BXoU=y|Rb>^F#&nPOht3iS0QdpTHcq%S)7nZxg$bA;np0M( z9@TPIoqW6BOZfhLqsBH>m>o4M7od(je=O9;N%}Z(Ds#&CQ8jZu}F#>CMdBiA=%abMQbBg0^8K13!D2s zJXVzwk_{zr0HA5=mWG~5B!+pnMsDg=R22tZE#JQwa8j^hg>IVR6UmKIC_-SD494Cg zC_eC9B6cKv2W}y{BncIEp-Sqa!PPZdC?uyyt!a`(l-zB-lGpZMUKrbvG{wqHP>qqJ ziZ+{cYv)OaFk6HF02f5W>G0;?G|=#nDR)JPVRdwra`_1~j2Cc1JNu)D7BlyW|& zXlC0Px3b)GzVQgF>F}C*=^hc8>$46xnQochraW?t;WEHVig^|Vk9i}qGdhMoHUqae zeBv~Trfl0$S&9<#Po~=37ZA%8xW*;@WUZ@@5lQH&q>@R|l0xV~mvH|8C|t6SXUB+b za|{UKOI);6PTC2h%J9dR@meEHV5>4sLhEyV=+-QE0b_q>7pcr?8)?9iL9S8C^)z_a z9UT7kDx}R%uxO;Py}|J(n|0|;ZL}GRIM|+9!(r(TMX8FQNl`So#T|VWhrFhxZHQ@Xm{&u4=s49 zWMrY5wgjb?Yu#7mD=fcIO?ZQI*E+nubZNXT5u$bzMW+BtbjgrV{{WPRIt)GIVn*a= zp@K_W*>l07)OFB7AVdnmhhaY>hBKY5EW)tEZKMNKtb`wpq~_M{I8y^*18oR6O(i^e z8w11RZ_>d-O)v{_{{SM$TV6C>J>_{wgwcD?loH30O+@hOvLp<}edZ30t&a^YmNilv zk>Hx*uq)-Na0isB3NokwZn67cA0BDJ3N?1NP@#aFwwOjag1&^du&>s4J; z+e(Cp#8``szy!X&%iQsCUKE_C#X`jf4M`PM6zq!8LM`R$tlng0Tkg=`>Emiv6!wF{ zg&dI;4kL}V46G%a4s2ystP;%29Tbt+ldbMNI9%`{C$5}t#-J%6a8<3xu=7=+l1Vo_ z;ldkPfx6gU;PQd!rD{hCP(? zz_+s8YVFb#IwH2iTWRvS9p$7+ovO_s2{Y7y(l}Fa4$uYv0A~{GlS%?~iLPBf!*aBJ zHLa5t#f~3UUzjo4x`e2XSt6*0BMfmu%NRN}$nYz;^G~?G^QtS%AtkeoSFH8ZocB>l zM2xFO^WpC-O`{Fo@gGfx1PP52X&TNnKW6MYsN{?Ski^1MM*jda=8LfgXKQQp>%`5k z#7%qnXcfpfZB8AR>zyDGO%yYEmKV|4lV1+N+l$utDi~5^wo;lH^7dU!z_pb#&gEcO zk^pv%BaSuISKDHEg5mham0KVY6s*L$X+|h9nx8uB9VJaj^EJDgeYO|&@i@B#ic-5_ z(}f9G7Ei6D&N#zEbAVy$8oH*ULZCE}?;#ADUuyg3_eQ6~iS90dMAneeQ2?cOrjl9iOil_nhYp?Kf>S2&&Mx;&dv?%sZL1t>&XP7`NWPv5>Wq0r zu4)ZTHL;NFea94%Sn2HW+(o;)iMGkJGb+ZqV_pJjUxEpI(M7$ z&TPrGPX%rh3O!9FSu#>pQ+X*PQ_UUh(Yet0gQ(PTr?Td*8Yx(%cG-ihEGac^xkoZ| zV+yKo5E)b*w zn4o#EI+`56H8`Z(FPMPIw^B?+Nhj$y;Z=a1z|&RvO-bYTlWlf;=7bc znogBP6pp^qyt&b_w1meblg|vGcVP`v?YSRM4l?p|QY)>rtIITOu*7BrMy*d%a6ZhE zPK$H!7dmn90ag@{%2Tq2+%B#xD!**7G|f_kQ_9N4bxzVOJTWJ{4#Xx=u& zXMlwU07TyC?g{%o-rR3xDF6{e-$`Q?8G<@GRx_2s@#>b>-9Wfpp}vB5eH<&hSpXAH z+JUMC7Y?dmsZ;Zj3r-+d>k*WH$I+=DP$!10s8bJ$=YY{&@kVBKr=g~&qEQ*z#MCn% z;U6})4w2_fp}8_@W)+0PmT?GDqEgsCGv!s%d;8i7mUlv}Zo!E9zP>c#$@8TE0YlDJ zp{k*hy`cit6f7cgyVTyIHyWQEHR2n!NcE+Roj$Y_OHo^gF`?MY9YnP@5l49A5x()b z>GrNI#SO#`s%>r&B9%QMtiZ=}K{@@jDznEzMph0Zp*738R71 zoWWO9)0!+}FlFkz$DAlC>%-=o7D%wVY9E(@0xFQ8I=V9*PTTx=MRJI9!eB)lHtZ)F zE!gfKTD3T$)zd5$1d%Df|u7ok%~B*BIsRRsQ3)u!IU;OyK5 z?d%rj^TFpQ}lFVLLNh|~cb8FS3U={&XfiTT~PIvWFX_3*uK#lTNVqZd&v zPYNb@q!G(sNcBJD=G`x!IRF^L?(g}Y9Uzb>nN&S`N5|=~kL%S!!YZMz#b8)z2`Zri zR>+KY_t04UcnsepPJ=?d)pPHo57um4W4U_-SgE|3Xz?f_B$aI?!s~DLK+px#>EU+h zqq|#}@cGf+cstOLD46By+2O)zqn%Yjprb6qS1KrATMv$$9xWuAkI=aCsrU{s)s!+) z$rsDCa+eUwMc6P5TX$<|_j1Z_VXBpJrREn}l3=(*ZiK9KH1R#JwSv*D?eOC&Of1&Q z@S^*j^90q@wb)RQU8W{FMr&`4gGX>}VQcW#+yRXvxm=8Dd@;=yUrC-V$gu5=Za>`s zwXOA@Y0tX6+OVnlcB$!b>S@b`D)7Q2BwUX$czb+#RRJ}=^B9Wi9BbujaY~OkEOk-K zO)LY$bWAQb`1`iy6pFf6P1z1An#zn;rK&bkQqwbtTX8KTrIocho1J*$qA5EmAyg|+ z*2y2slEtEr-e!@(C05^dhQo|3VM=7sq0)0xHg}|@Xd127mk^d3SOHz5_G!jadE^nsY)}2NzO5xF|a&pmZ2$T zT6{($Pd&()WS)geTEGGY$m6W1RMjq3fTRUhVM!?J6)F-Kl?00T!abmUT(!sD=~cH+ zgx4xWkYcX#63}lBApSTQsne>1O(C}XskZA-_7CMk;IiA_wpvpn8W z(D*QjacCYfJrtQMgqi?y{{T7l}- z39gq2!{b#B(8nw?OCTi%*%?Leb8mLW+)4~9ZCxnVl zK{9Armkxt7Q_F{$T8@KVYzNB%9r4@$dx)d7#OqGOa)kH5(MfYjdV0 zR)V3hexKp2Pw1Gen53&_5yx?Im)BqTlXwml1^4F-lp*egsFE=>U%H=-VlqHlJ+yEv z)X-32H1_i8;`xZzV&AzpyD`+APX&2xvQRLfhGTHGnL8>v)2*)VduTe7+~-yT_!RCa3D{{RXs$y<$OuBf{s$5%m&(b9^EY#G_`_`x2{En~oD z^f&u-d44o~lQ?^&dHk#Y*L3_+u=r-gx-(53Nkx)OR-U2@TqBxfD&qd%Fpr>e7u~l2 zTF+O^RMT{Vq^7m{&2Na)=bUTHeV@t#M+!L6l_TC-&)-5V!KxGrXpQL#BZUT;zOJJZ zqME*?OpMhPetk;~074ZlZq~K9WY&?7tM08N=iPBNU)662Ol20~T`e%-#X5e>x?2OkI@23!@f3(M@l>`9LGznmpQzcCF zlhZ%QL%U@_2F&}f^;l`cC4gYkKxuu7VDe*_B{fAnJ7j{611z@%S;PYNKMgK;mA8CG zY0#NW(5>meJ!USJ!D|E+Sa$3)7^SFC)Od{x8%s}9A7+i$PiQtEf&t-fZEA?JNYF`Hgw&rluLiG@AD9uenipNHJh?kaG(PYn zfHog`#qRA}4#UjQvDAQ1zIgf+=E4q@ofQc_20cyeu!<;lu%Ysat6Rv-IXX9~aLj4#iW*h(kSf z9LsPLrk#cmK1DLY_mG`6q6DRCI;Dd}TXV;1;!zUKxq8CZ{j96}x-J0Cx+4*Du71%hi^D-(QI37fFDO0WcaD) z8<9x9pS3LYIiJck4OvpJHR3Q;)?rZ9wFVxtRpN1p z3`5A0s6t$zwby*3MIJmabxn=5`2=H4zvxj?Q&fPmO;WXWF;f;}5}Tn_Z3Te7zkfXH z=C08KnkTEEnd{6@pC(e$p{TGbZWn0V;1pYx@m0`)258gt&k&-g^z+m@dA66t0ig2a zH(iFTPj$HP(_fDYuC;z;By`b=2kebk?mnvyS;OkxQ13EPd7o;;N=XN|a4o@0V8{lE zl%YcZ0HwtZmvQ>2VOfuxLrSuNq(y~rLP+s9wYU!6)nbYjZn)GHLq1_+QA1Xw1d5*( zh2pt8366rjHtX!L*N8WGiBRJoIy}swbcQ8#e6fEGTnry9? z6vVMjSB6o_vV-qg=u{Bhzdk1*1w}mqF`z4|`9_1vinfxqsaa{a3VT?#*JfruH$AV# z_Ku!3is7(CnvFNeL4rWZhyqM8houJl8A(z*4Rqs+1e&M;H6sP0f?P6brnGWzfuagY zT_;rBPhf6&qF~k538a2z+l3mMm3x&E2-!u!ETwIyjlLXxpcNF;iYcc4kLFnBe0L74 zf74VY;Wj0L#;omO?IYvM-n3v5RJJ(5qX$Qa%3>1+h)ZNEBPk3OhNo*1I~(x6DPf(0 zgg%^RN-Uq$JQA}QmR6)N;xtbT3`<^030M@l9xKGRZIz&bPOx+;O)V+$iVy25)>79j zFiXC2(iLLfVzh)<{11uZKH$bQr}F?BgVb6&4Cw+ITJr?BO)W+x2g?$rT6(%P1lW)U z(Qr9-ijj?J)%S-A3Mz8#RaPH^L0dY!atRutlS08;Z@i1!ijBycWl4?{t;=L7Y`;l$@c<$%xXLT0EI^rzAy%^$beEQMULXwl@&c46w*mchtyMf)p09-lqOUQ zr-)xKx5tgN-m22m7*mc&l^Y{w8gVg;p(-D&xViiik$V^V)_AsZ!tZ)68Qh;CRyqyhv9AUbrG~pj#!!Rf%PA zL~SZa)dV{0p{$qL^zmicI_bM?MM`WoJS!k>Py@DuQTdQaN}o9$C%6}ms#PRgLI^kFl{duGK+pr#OhnCv)=|KAs)Hq4D(VM_)7g7) z%E>UUx<_^;G{4Gto@LIlM=zfAd4C9ohC2L257HA$MI1>CA+$2M9y%!ZkHszen`lX= z>`>#X2^1mb99n}V)#6yzEs4#HWvQs%mkXh#Ri<$aQ3-@w9I+*(QcImp$vRkYI*nIp zfrdEHl}!s3YgRn^&~=L!C+-+hcns-^DnxSKqM)Aia zj~YfmAgCtCzP$5&HEbf0RoI;|#AykbLgK0g1y8-S$OnnHhu6n|t#^P@wu=&{3_{ZR z?NvX^3bWif@X(uf@#0cx;AnH{%So8JkCXEJ6;Q&sq?I^8R87Peq?27PSf1ZboI!Od zZAO<{I!eYnXx#O$(w0=A>6F;E9XVXXG8##tl_Mz4ZKU5#x4p?a@HJLjDSNi5 z(oY(7{2pnZrvvL{6G9A_eq^GjtMc1)MrEN*;dK4dEOk6ny={Kcv(;3|UM05&U4Q@3 zef(3&IG;u3Sp))}Olq=eTFRjzqo*KWzMHhxBj|63u2ST9k3P*1D;P%z80HDRv%A6z$Pf+6&RrzAS52&qns-Cj4Sekg>^sveA zuBa?^?d|2ATqHSmGmDJBgHnt-yZr(>h+2`LpLXV&M$vZPvExwQv*N2mgh3co+_uxxMD1CC*CY+z zN$9Fn?y$ewPma8C)uLi*ttC?=P{$JCa^$=|nmj(TlNL%ZB4ZUTK_nYq>$2YN+uz&5 z^(+O<(SUEmg$G%C5u~E4s>7;bt&7iTDa5TqQ)1#Va!E^HTb?@P6Cl$po&->X(T<@_ z(cCWp#j?}X$C+c2nvWX8>uIX|nUF*YT7)VA1o(|bt_VCVyt7TfDOSo|XLP0&;oDZf zMGr}RTlBuO)*A!E6Bs8eLj{fA;vS7u7aq{?`P45mtH=!Gm!T2@4p%OST0ztzD5*DLPzH_?qD zv}K||UIftp0E+qr>5e}gUT4L#)-e@pMk}#1EU}VC;MQj`5)H~*yAI10lCBL5lh;y91x!2DsHOo}gt)mqync=+dDH~rcGsbLh7_~S zl^M<~B0353Rb&+v<|@@_pqC(LPqZ{WxSgjFz|x13urL%6RN*yAi91HL5;W^TVy0ykgJMv#nmVJr)EJ>4F;DQxaq!}Mq6#1$G@+t( z)Qn}Z3|fw{Xz-fWd1MAC{z{}5P#7x^Q&Iz)9x{hQcGIB*<3Yv&O^ZGukB{V-rWzS( zDC89MRR-Zz_chrExAWr1A4o{XlQxs6;ZsvLrcjnoJ1=6BSE(qzZ52lFl2};Tbg;4I z6v$d)YT@k!NTE)jI#Jg}1uZ=_R1#Ow)7DDgD^skI&%CMkbR%!)#GTMc^`${&UR2kZ za~2^9se&qMlNeDY%{@nbn%e8$>)V!TDVn3IG}qEv&y>P3j7JcquBD$Bshbd3jU4L6 zFDVdP+}BmLz8rGtLO_~ngc1pjv@PLT=M$iZ3dAtFTw;?Dctg0y=N1kykR+eh4W-7W9BLA*0jKeZiV!mXY_3d)U4}e0(M2Q7 z?M!JZ2KyD*Pq=%5rTD}E;HTih08wkqnDulxB2b(o5cwe_(maBadjQfC;GP%ZqiRW3 z+AVns3E4&m(S3DQMpMs{)-04%SS3vjl4zujndExM8-uQ+L9YT^+=)^mgj=TUg^CsP z9d#?@+UnUIoB4(@76(Q9vP`m2Vh4Eu_avKZ;mU6FU$iOcA38bDu7X=mHC@s527xIs ziY2Kt3R*ZY^6;xQia?RK*&YOV@O9mtwI3z$Y9txDrEv1pP*nWOJcUdVOkGso$Ly1> zxnRkWHBR%xLmfv^YvaIjzF$P1DQW2Gp{T8nl1-?K0>lA32B&Wm2E>y}wUPje>pN9R zieVKk9Za=zBuW^=9Iowq-oP)%n`uc0ZBgWyie{q0sVAeBpw>x4B{HI#H>RFeoRUs~ zMuy$^SNDDw<(qH_Gfk}}TLme)4bnW5n;QtC#VYZ9BR6Al;`NYJ(Z*Jo zMNL}th&M|S19GmK>wZ%9`C5z-9+kUWWT`leXx3uhn39&AY4E&95vmfm%bBYyB1MkF zLv?`MXgEafZt_h0#Tm6?(uO|+LH0S(L6&H1v8=~ch@rw^ddX_A+OIwK`Am*>{J!Dt zvF*w=o4B$CIIO9-F+|CFg^oj?vHTkeixIEODzue&E+aKHL6z2`k~vC0xofFn4TlAq zQQd-0G#+p$IAdiPY>(6ewHVbtJ%`lcl=T>NloYL5Pf!BLY9Wvnx^_Da&HOFGyR=9Y zsii@}oh$Rs1Te*po_S4B_s-gCh1Hk6ig??N1_3*1VQ`J2pE_Nb@GLT;AI7n{=7K78 zrm3W(mY#jnN{KJHwo6>^@za#NM8F&>tfw4n+1okCj%G?I@Tysk5h8rM;syyeM6x)L z5xGW*ZFzQ@2^(uqf=R-jnx_lFa*l1IOkCDEo@nUhris)@A7ddJ3xIBXJ8>{vs2X)1 z7RaOyF`cm-(N~zWE@s4Pv8=PPkJ(5rct+Vbqk7yz)ybNA5=&pu3V*@;i6?N5F6-;@5WWkZ_@EDMgcd zj@}&OM4voojDI*!m@x|cE}>?g84`;Qr=_Ub6i*ujM7rGA+T`~<7uc}NNC^gl7q^Rj zWl9@sf>L5IV$UslOBF`I+kB~68*wdmJAJAJxTVX4#s-nL+J-SfzBL|XdYBd(I)fcN zk-N&2(vUV(#(Qn>HH3)s;SGKq3dcaQcTZ=`3ty24inT8Bj^lVNE!- z6Xi{Kjt5@pP#%L(cKLKvy_5nsX{gZgV+sP9TJf4cmin;ny7I+8xz8FK2)d_8IdDDD6xU^)#w{@K=#t?2BW`-?ZU;~ zsU8JV-^!)IsWdiZ?D>^?gMmq1OrOi~npQNp_5oH@Pf1Xt-a-wxD_h-e#BowmkS34> zC@LvNv=neFd35g-Zn~C0Gy_n-e}^nqh{l{Cig%&I;Ko{#o~DjT!zxqls3k0`*@!pS z*~VQ_h&4pITR0k7)bzW{M4C)7DIOSsK}`zCS8%o7z+J85elipQs;S*%leU;kZ))TVc<+2yrh0HI@Tx_A+5ah)V> zttrDao{ui&sO5{v^Czf~?JGP;%CB*+zASrj(&tTkA4-0t!XWbGRi@iaTXfqZjZKNM zzR*7|Rb)m38rG>1PjO)J&3LHj7^>Y(NQfw4dlu6AjxeLP*|l9pLp-BD=W&h5lDfS;oLal6D518rQ|sw;=`NT9OqN>|n~<?vUTH@LAVJ70+1w+f?l<|R8S1y&ZaPT*0cI;bk@2w2bn2qx=cU^tZ)VK@r& z`H^z7;aOKFQC5shU~QP{n(XQGQO8dhwYTj7Nzf5~+;6!lR?20|l_@bWDM^WcRH3Db zKao-3iSI0bEjmb|$98~&eJ{fnS_$Dr&bXsM)?}u^s;R1sbn&%3sPh?O5yZ+u?$wkp z#>DWKI8wmdg&pOo3Q(Q2N;)*HNyW^||lC8;+=&Buo`i z&&rr|Gl+b;cnpqq0pzGRHof+*3s#}9QJYRcp^FZ}F#35?mZpXUlW1uXsp2JWd@j2D zcu8?{0++UuNTtpjhGgj_OfpKU6IDIRQy_vj14h4Vi*TH}c1F{`4LP~}{SLkk*- zDQVVaEb^2W8tw!TFX5*XIy8;6?|P+d6~>x}r?^_BLSu1O#~>>E;57t-ek*-1!ouRy z{72bK2r3w)duc(3;F&icq?pL~eR8JQgcMZq31S~?ZnAaIHulcda*j6V^h*M@Z z!RgD$)ijm$zGQMn>#(3#y|mO{*}}`FRy4w}^rHk`>Iwxo(3ek@dU*6vy$wQRxO{Oe z>sVO6tD`HCp|S8hGG&Iq+eOQ{aN!$k1o#d`^JDo;9+H^M3r9Ru@JGB2PP;BhAH#-7 zc_{$WPZ^ovQRT{cTB2B4DO2=!Z!KblmrrfQyg1v6Q;HC9@~tIdAlDbmnNf^#NruE; z8>nT18+*ie0DT-#pb}P6^C(Sm-sevJl%wXMsbz80P+#B$h zHNNnKB+-^$!3xx&O_+C0a4bFwYG`OAljSa@>Lyv(=mw?37S#9Uvf`y}HM`rBt7SP< zu9`g<&{NB$2HgMi&17NOuv$%8b@g zVib12EYoBNrX6!xkSQIF;rVt*3~x$sU3t~k$@7~1~$1pQntyDCV+ms&R_i=Jr1 z>2Mn2`BN>nAr!}bO+mFaFPpdoVds(=kAkS-V`^|K?lI*;CKy7~Bv4nM^A=+mH7#92 z(%^B@)T{;YxuKGxM^Z~hrXP0uE=}|UUK&_;uc&kmG>Yu9%6dtn%~^`#+21qK;0c*x zz}Fl90DE!CSot(mg^aAQ-o%gwo-B1ev_84K45P!aQC+Q(S(8TNCuY8rej*#H_zd8Q^STL+|Z!ZrFn64F5Gr>&dhU=h1?APhx zlS_HvK*E@M=?x%Ap=yhzc{>Ni>G6tqi&nsr(7Y1J(o?)osrO~xq^Yq7n`ZS^>%_>U zuYmh_2&H6+fzeY`JI75TklQ|D7*D%%YwcVA0Cx^mou^F{x0ez?HN;?eYpP34M+zE< z)Vg^Qk-5d#fwX`R@Zq};0+~E%8|^`XSfk5$cJ}`OLW6txgaJzx!`K0B$a@oU#{0=s z(}_vZT-O1?#Wh)M8kfsDNF=3$ak;hs0LkCKD|V#mCTZ3}wG1dO&MQre(NUt{G!WBP zJ4XvgMNY;i8Mqt{>m(oFs+Qpbr^^rD`r3)9s{h{N*ENdW~Q-P^#B zISg*f2ytFtI+}05AtJS=^%0L|?6cH*tUD}XvrypllvK4bQm|Q4IT;4+p~G6{{E@9K zn{mGooMZf9Ifcfr zyveEK)kmv5KB73{>#kv@Uotq$MI|+mGlakSBYSge%B>22xr(Z{0(HL^j!6+=TDXNF+P`FSiUGpv5uBunIa#`dBBX zjo_lEt5GMB61s0LLbCQE{0r{}Rc@61piqY-zk8&_<5vBdaNKIGV9dEjqFPK*;92Xc zA|71t5`iPEfovG7p7!nU4-vpKPNgOlvV@K@qvA~jSl)f>bd>ESH&yCBevEvY($_|d zBwhSNMYB@y7D{k<3yha)zq0q&Be* z0S2Gp#Y@QT2E+DMMn5X(5Ummrp%#qY}`yG;1blY{Ka0@XvHiJQN&m5lGKEY0+ z@!9*0DQNv@dhC$-v>u@|0fxdqBV`Z_z_zD#K7+>GXZdZc{eqlr_hM$BPpyB%IvP2` zb;B8|mXT6dr2hbYz^|LUf-Oo-z0=Pey3&5pUi{nXm^8!w-TuER+8C=k!H!eSFfvr5 z8ZqUvH@XF&_8alTlv)$^ie%opIM*q?fBNZ?nzkvr^Nz@oNNJ^q{SjH!qghU|!aclU zd%tFXfKrC@d!(7vaHQORzkP6Fv@%Ia){JVJL#Rb+M>|S`d$d=-yUM3_EI;F8pIXxM zo25pjlS({0*Qc$#UkrWScg4Jz%St1WC|N|Rb-kd`jqiR@&DOC@{>*dhP9rzC+o;n- zKZvKVOfIgb7&_C5;R^v&S&}?9Ms24+38%fRdE{=sUXeZ6=hnRDd2(q*` znehBJZ}y1B>&7G=WCjd6{_B(j{DuDjbB-L2%oxxsO1^bMW}IX7+xUY_%Jm&_#S#QU z=Av4BHo=%}0D}h`{!wR$(kiIBdu-FKC*mFJb1z}=&5L!ar!YxbBUVEs$wx@&v4ao; z$c$-q-LH=tIUTx;0TD`(dg?$28jnx-oqEiptBS4qi7-l!( zhVI)&%Aw4b6(b6J#eWg+T}w?&wB1Umf}b0wS%bq*KmtHVyeuKt?F|X$hDmG3ZCR_A z3E54t{vbZJeDMY))LE;|d0JXIDr2RLQ!|wt{mATXV0Gt?Noq#Tm0^DB4G1#&&h=S} zWtt|g#ihjm0Gd<9GreU@aWD>`voa(=5JrG-z1`lmaeg624QB75IBlZOkNTJEnHb2Z zs`rCc}QqnUFKXM@z{A)66p zsimpPwD^CRAc^IMQHgnhmK9O7DuMLdgxl9-hLVtqy_MUJldBpSzY{9TEYV4WQ`10; zM}p$?jfT|IhmFjK1;rs_a6w=_;1v6}@4}tcd&In{d((AKzN=j;?i&Ak|jU zWfIwTEJAJa$puu-8IbKV6qGOo?eOH2`6ic%G#7E=or1GT>mSwj8u7t~bz;7PO~NQj zc>qVbfGj^mc<1taayC9lNX;!FwJjR_o>C#9I^3 zT~qnx-`W;wUxxbq^`s=0ix=wdCy3f39CJ?{5|wo~2i$|%r_s$jyA~?g*yq-iF`e9} z_>D?W#3R;C6zf$VR&fMMHITBhQH7LSP(X*_+;Xk%#gq^bG3TbLtljhcRn#Ae&#lQM zo$#)%;y8M{FU-6&xO*!SHiFlK!rF1>w_?e&Ap@UUVOhPx@G3NMIu+|f)rV2?t_LP` z>fR-aSLP`(4<#0wk!jW{O6h6V<~TsTqrH#p;Bz~$wP@gx6nT>VVZaR0y{4<`zB4>{ zq3Z+9RN>eP^?|kqup!iFFYLDiO`|Vag4oBX{xp2+SBS$^H0PeD`hm$gUb=cdu{Av) zS!D7l#Vi5M!&v}83pu`>$>EbWHY!$~1D{$hTbDpdCTgfUnd|q~o(t40LkY`WbH=Ig z8W^cDEHX&NBuuhROswL@7VN}=FYVyBFWs9G%1WCP&s_(vb32r}QdDU+KN4?Wf}tJ{ zPgk0Ay9e zgBvf|_h9<(#udA^Cu?J$T6ktRDTrC7+%MNxt^9FoWNx=t(wa#HG=^9x9F{h1%*Gz~ zZYN&qWv6RN_x?1c8U5*)aEhD$+8(x}sA=1;_@v298P+&sq8c4^v|aCRY;MM01`Q5< zYs$|rN&e_!m05S!53YPy3R=JRh{mC%Nu{TY4~`r>fKiA#m@jkj=FUfAfv3A1`qN0f zeP>Zon&7^+{cs^gZo1<)sl0wuM~5z>w|Fhv$D002XZ- zv#xs-8FTvCnQIGW92BNn%eX}mQHW+5@->DV0ks=u`R5}~xNtJVCBSWQRbZ}x{EVLLrX&h2nl~k=TYpv{Tc|(%fD+M5P z>s9_?a!1}xB%9Vht$I3xB>iT@C>p3dvB6CS6)MaU>^s11+Q;hRly3fC7$8rV>rJ_u zU6c1ywlC`w){QPLUxcSsu?atth+4jQpu*DrYHkB)fO~&$G%`y#9ud#2Z}ZQdCX=*Y zv3*g28{mDG~(?dJE{+XwlzY$MX`DX{FqZ#J9 zqOh_+*rAe^IT$ZsP()Ytw-h6GZFmS2%bB~pY72fMp0p>1KR2lLkw!0MjVS{XMT-Uz zcwa%sKeM*ch^?I6-kM>g_0#Js4#X4Yx~X3!MSO`*NhHFJQX^u)pLAzS3w?ZO?!}S* z0ah9H%1_*BF`RvO`puFDNczKDMufCZ*nAWWjKlYrbRxu)spG8f)sjqv3TfQx;E%Y~ zzWxf`V$Z!)%D$knZlPn7W7xeeV!~;n#A`N*Sz8M89I#LayvF)=;B$N|+h8CdMJ~vm zTiS}Tum96XekAb8ANiem)wqwNkdEyvf~n~F)X|xbwzb;p#uFwZ z)C^jtFiJfj`$E?8lI%YINf~RB*R2OH(+^`vn*0v9(}oB@C>WLpP%qf=Kzs?NQqeS$ z{!2XV7UetScu=_nTlBzpKF&HG73VF@37D=`o@bQKS#^D;*9PR;*7$KUE^x-YrWG{v zmpXpUh2pSCT$<^rW2Zt$KK)E<+sD5stD+5EEXbh;HRZW*Tr!>MVrP~Zl~^k58?Rw| z+TdJq8eJsGr*pjaguA+!VS4J$UsbTI?)iVHiTwV*0g9#^7a63aj*=-U zrLT%hm52eqbj`RP*V95dBV~DmA+H7#K`g@AW-zJAvO`AXA{ypv-JE+h0MOmlT3UdrdSnsO=r?`Zt(?U_GARZA%1KkkJIx3|9)w z6%~=!NChmB7BeXYgRro*kA?ZB)<>0j#zEO$Ofs(&!g0A4DC5KyvYIE3NWca^kw95M z)anSZ<=nV}DTFm6u8^3nM#ZB^DngW_rxAUn?hm*|zQTC&ZiLsJwg6OI7cXM;bQpvw zADu-bOBA9oZ*W51JJ&XT0-%q7J%syLT)36;j z`J{qsqTN_fTZm-5LP;d2RFa-(CJZ4}ATqDL*o`hYskhU{nRT*74w!COTHFsV&^*kQ z5ztaH7Y6aXk%q7&cCq3I7viNz3W}E|NvNS1WR&uioXt-Za?X9hdDTHX@5-gjajPsq zp=bJ$jzNY{OEj+7U1kl2*5UhsE$>oBTG!NA>%>aC8lsgqY)GVpohig>-x{ZCbl+cv zRMo`$NETRTZQ6V}wOu4vjj<*w+rJB(7EG~4>JZaLMQ_h##=0)65;c0sVWB<2(}CUS zbe$S$UR(lJMJT@$3W+E(Tu)5TOey7s!$K}dY%aX19?}c3z5IAZyKRu_`XY`m5*FHL zXsTY#`A|)X);G#M9F+9NN?$yNvld+rmKrhk@=I;N1q2j;t+WBx;5Ab{8M$lOBxL{# z32kwIqlPWK0HkiTLBf={js;siC-R~Ul$73GOi1=A<}o75Z{c%s@#ggnqN?I?ikp`* ze3ZD>9W7QIwMkZ6%8kL=<)L7`hL$Gx=AU>Jky>Ss6w{6=)3=7D?}d30)GJ5k5PjAy z;eVryw{m#WwXz7N#OVzAmcB{~Shh4U%~(>_(PAt0_r193yhu#b2)D+W>bglLUyRYb zb|-0&IM+daN7bi2`QDnc?MhYGSa5!%b!#SN+&d%XtY(`Jz-XtetfGQS3V9_BB*vwK zNW*aj*qdMB#-GcWe3GFxX0s=lOeE9nU1{spYt+%jnegg&sM#EbmkFhTFThGc>LJP;qaJNKmi9|9WQ?#Yx!NX zVp1`yCpWq$6G@EU)4J-cQkte`O8iQ%V$@Va3PQVL9$JvG=rkW$@5448N&rtqAh`>1 zT8`RF;XN*_#A-2N@=F)W8fe?h+zrp4sMEc;>h4knCvAmIEh>6%T~C87LJuwCatN2;up_wTk#W~v7UC&`9>|roFPGt|Nc^Uj2!)h5 z2w9j13UxQ{eR#c#ouJZ3nVqz(tm(<8k~MhL#zJhmY}BY=0Pwfd#=kInYRR_(k+{}M ztDh3WVpzh*Jz7(VSOrBp8%^EyKHfUr#@edw`Y92d@^rA!&??41M5G9T8-ek-Tl;x- zZgJa8uGoQB1Na=!&q@JHH*+_~&q%rx5cO-(oAT=XGM{Y8kf=)H%APtqvsC_-JlAee30Zm+xQ^XOs z0%R&y`kgFC(akq<1kF0*WJNvWIXWyGHRP#cj0PBmI!Y=Z-DdJxZ>aGH!<$3pNL1Ap z)GjI0GG(e-{6`RqrmR_nlDb51?v~JBv9^NzWe$;rZB5MwbU8~4iyy!!(M%$ytka32 zUB}CKT$9-8?(ss_V!Yd9P&Bv3G95-Z>pzz&K(DxuFxiYC8|nbCJ@3Ya*@|=W*zKl% zsq~u&sf+sH}>s_G3UaS2|~yvxh~qI_K`6 z9471WNv$qdR4qQD<$?ksq=^^{yAO6fWrQ$|x)8$6k7)P_&3#&F>T zn2j7!!;0ZE7}lbWRtVa)z2yh&K7jV_2;c}U>nEXKZ>Xr}{7Y?*=5Q&!^DHFlLLB!-qZd$A{E zvMCyP5ydV!5lu9TSH~>~rc*s2Nujey$#x#^v)B)S;!^e#PbIQ3te8F>O;;o{$bwg4 z6bUKN{){BgI}{Jd%_DhzN~LA6RMj_sn@dvDFQ_^THDH6tcuF;_>K zafvC5E*(`3GOO+g(#JxR5(jUwCbs>Yt=sVcRU2k$r!?ibeoCs2I8skB9d1K-$g&IG z-$y9ZgHl~j+WelBBB@(n1e=wA8QtBEisYRCB{X9!}qNS5n zWAGZYz408I!Iblz%=A1KvQQ5sjM!SMQs$MK5tam(jKb zPVy$~N*^L=0$3%ML^k?B;%0LhT{!iS(L88q&)5zhMTBIkn56ltMa!5JvC_^L^geD9 zg~0e7pxeI?u=y)E@uiS7iZ5Ab8N+IG4O|d;dm_VXsn$YRZQD#`AX@$x(~FjqrjmyQ z)uDP2!y%6p>n%5$vDQ@7VC^k4fEdQfT*_~uV4*$Vf!BojqT~wmBTA%FfAJ>6K5M4A zMmb>fq^idg3aIh-R|cw@#@5ozejG2zBs{a#Mh~tMnyqa2fk6%xB*sWv&7?6YWjoY> zpnwP#xZu^NaiTS}D5Fh-Lk%V!Pvz~JNs>1of1!p0aCv;0!JN0TSAaF?I-HE;ac8`Fh~`Wn;~D*=CD z2TmuwQPe!C`&7zlHHy&+DqK}fJd-m?C&{~^07!HIpNAbn!lIf|X+_g4pN1TjgjKyM zX)zo}7fQM60TGA(U=bGJSbePr?cz(@h*VOWR#T!)3YfP>FuIIUsVX6QWs1oqO1k-q z#kaD@YXWU^@a}k(tK-8OT5Xd!(SpG;LS@XohSAYb$xnh(`I2DN79_GsF)~YY;9Tn7 zE%$L9#mtSk(uS>qX&pm^{{UFAO5=&te8lFU)2`v7q6I*z27}x2;zrgHvXqimWYD2q zl&OEs&H;!|xYouo1c{w})n?S4w@#IUJ#U-gAsyA+ldsTteA1)?NFD?lZmyw*ECz;$6@jUKYL1C%>ZexQv8kdc2|g#5oN9_58g0WM zqs(~|38kQmeAr|zwL&p+sT;I=jr<5abL?Gc_|X(L^@$?O*?S(TmK#W?=3c-LEmR1> z1dim6A-7mkpi-wWMFSafdQ4XfjSVDeKKdI%w)f(iswU8QkRIPp7RrHxNE4*tSUUBF z&+|EIC!EbwRfyBl`LZsp7?9rA*Y}4nYPp)*=^;3Aq&_{BV5xjF$_j;NhC?KR!rowA zG&+skSi`i9#B|V&iDa5*T5lkv?>5$dFVewHwe zBUjUi_M!W3k~NRg7stnonOHQOpo}RUoiG?+SzJ@tvb?evwaLA;KHHvo4r5kcJ8H;( z1&S(qd>hm>A-ts+_8jO1h)^)~8tK9v^fHurQk;_osw@B1NB$pO z#&jNS7OF?L+!j28w_RQ}4yv2;1~jP$q}3Sp(!BowUg;s+SWAae)2eud2*>!I4|3Fg z&U)xSn<^fuSxmri8i^J5O#;YUcW1wQd~P}ASDGFXSsS5 zN(#AQWl&hlShiVrd%)dI_>Iw|;ZL+R12j2j?5$r%9vzBc@`r@eL0M6Q7H=ucN~+Q$ zH`!oEZr0&*ZUcobRk;}Oq?UA{#4B^BPAYLnjv7fTpr`pY_mVxauqB(u#>D;HUeN&x zr0$@X1XddCypZPsOHBT1O;0UkQK&X}#Yjfb>tHyTyD6tpZYB*j;}rC;XFQD>0p*J0 z6D1UPVtkg`zVC+P---~w0;#BUqDbTU+q4E=DGd z6p7)on6dgkTdUa3spywqBBO;ArLKA@u4SYP)l0NymC`nX!5dc9^X-O-(%1H4CJ52x6R@ zd`DtDI4k_faUiCN(AJd@X&{xNLLq`;s_YR_hK+x1y{DE+aIYwuSkTwL9fi#!;p5GS zQ>#|lwJy^wg~zjvt8UuZ7@A{j(LF_de9DH>v_LBW0)UqQ3w?Z0hKA8i>M=sDL6%Hs zBfz?l2qf$?w%7a{E5He3yD1l`FEK<9R6juS5 z{awDkS-rDbckRNH(8W!M;5e*?sY_N#Qk3eYRct0BTldxYy-O-MQX0vJifm2{LIDs} zri`(W-sZx`x%hZ-!lIgUOo|e4V@mxtz(q|Yo^}sB@z7Kw>{bm|ETaB5)B|oIxLFH0 z(}+mZ*IY5I)jlzf;rNk--RbDg8!WFN1{N}wxE8s%BHUpO%{|^8H9s4kr^(A-FTB*f z9P3L_1+OQUh}05ItQ7m#=E(+W#>%H5>H$q(~;M)6flNMlqRskv7()YD&Dj0@S;I zltE8lWjfoi7y5V`&IA!XNZHH(UE%5Gi;&)v@tYRf?e zvgGVPerdxa!syxNnJQxUEUmOa_qM&SuPpMRCa9E|skxg7tz1^4<`BaoGck@!EtdNT zH|_R;9AUSJr-+h808fQAZex;)IF_PCN2rce1(r7Q-3uQL0V9Tbp}C~y0mi3gyow&W zK(Yet@vJUMHt+8nf5dg=9DXaw6H9DXJRdGJ)UZbK<7rD+_{&Of5oMM&i~>c$weR$C zJQWVAxgbz&i|5%S%Jo?7Ga}-6b)cS_;k>EYnG~B10q!rw0hnJ^RIZ+VIpdYMo)Mjm zY|B$wIH6fson2lk&DQ{1L$BS&a}+@lR$)ZpLS}cu;%o`&1ftBY-e%oh*%e7q;b5Zw z07nwC;RcpmHX^e0e+#RZEMpjLJIAnMq*E7S3Ee|Vbla_lxAt?_&jAOjsc6|CflA!n zl;ejDcqE!7YMD01kRvf07)N`t8WY5gU4n3<184}PCre(Eg95IloJy3?R@FTf1Ryjs zJe4ALL>>*M<|jZk_Hm1_R;)I~X^jX;28UUr!m@P)eM;)38@3ha{JsT~XxqxE#7Q?1 zBRC~uORt+LA63W!I#wq`dw7~w5-?J>bWoK;o2JcuFBq*&GA<=HCyEsm=&Kby5=R(< z1iqyZDX{wcl6YDh?%aZSQ{j4q#uQRAZfAut>biL)Fnsj0%@3SFZ#E|Yg(Ll4cw_l> z6wM|}o+zUmnsW@JAZ2_iiiMd`f+oagjfrN|+<~CJye|yO)I};wke@mv z@aB=1v!(-Iny67>T8EOMsTewo;npF>~FByd_9~_9wEr#Pn39eP$$q+3|UIHi6u2OjU2@)+@CO% zn34_2xW5)%DC(wc(cv?;j3=uQr!HoB6;?8KDhS1tr_Oe<*T;pKX(4o?xZd&@lTribww$=rXv)RYv8jU$LSp1 zp2btwQ-w2Q(ltV1rWpO?s(_L-va17OZ(!q=og6z|l>1K}rua>4ZuKsBhPYj!agxf1CgMQYwpB^e@%_f?0uuTTp z(+*hZqz@ou5i^4j+(-iV*V;L@6lpVtk5}N}u)%`*glMh3G5jz{%b*AOcs?IT3pcS^ zl8RB1Kyg+7)(pQ8G-}KA>?z7rlTl{6{KHT8Hd&rP*5;p~b6k$)};LGDj}?-CU9i zhD5j;kWH_`w(isj2A3&>gHLt%1`8auxSk5{ONSMOs$fRaSt6AR?r!!|bHwDD_i-4C z9r0SUtHJR3C2<^YK`I!Jy2G(Q-NYzPG+>nikwC{#aRMjE=AFFB1}Wt%M(o#ARyID{ zYknD9rb4L=%Hcp$YGc({rhlcVM`}b&GOm&;ghD{P$sr(Va6fMt&;X|ry;PRKHsGB~ z!Dy#7b$>I78u}-Y`Kz)>pX`HgvcTMNaU-ae`Wi9d?dHGDj3nbj%lf#FvTeAI&+a?#Z=M9E+k3Y_PjN}1M3c2I055E&>l{tjA(&o{H2Oy8ru9X6QlE1rGrpcsJcvn zm4O6yaomruhm5`y0UIeEoN*NKi(|}knx#6KrTKg`NB|)DjP)s@BEw5t>*KmH>ZXd} zL>dif>y}E{piuHRyD)hL{?hHY)o%P$697dtNC1ix@J!Q+;2kyUEO=wZ1Xz|LkjRY~ zX$wb%#7RSaG*B$ zkPF)C8(vaHIJS&ZgyWAzh2`ogkgZIV^`b!FsP`(RHy8GSuM;UUqZF##m=uEkf4%Vt z%-hIk2FJSw*>As!n{NoJ-4PK()iyH(xnC~DO9@)4XkvB3bTE}}^Z6G3uejy^zSK?6>Sl*JB2&+sW0>k9{k8h3mc!7l$k%1L(9)YQ;X>p#h zr8JSrh6;?oJWQdkMD+E$N^bb@lQl9^H1i1>O)I|>>_(z)k>vSdP$EoPr98GIqcdQ# zDzn>N*4=Nfjb+Lj&y_mTAPL)5N1ZBRT(=CZIckWYEhEWsYe*daSNixOWA38+kV0s+ zRLxf-V6{+xlzBYZwH8tveZ}X9a+#wcc~rEyKQ*E8+@tgG380Pu_uzB52uu^Rd|XirG>x% zl?Bbd8tO0Kn?q(zHMY9KB>w=7Mh?#Z03bJ2Nh9y_$`6*6bw96eX=s$0s$(>t#FRAHhT0in z)Z31-B^9%_ihd&ajJb#TYT|wXpg>>0MJ^#ca8^K<3n&c40uOz4;fUExnF^zi>AMNT z@N6%s%UNo%5y7LRkbAEYl1i3xp!n@eeFudX?h~dc#=)s3hJ48`OT?UpuA9uBng&XG zD4o?^nUR3nFX6;VD)gfT1e_@$mT~$lwTR{nK8BK6D59Dw#v~BHJ{L#0{U>e6@Z(7?TIV;0*6sBxOKrH*n4ud!MvMz7|C7zycCvnt7{o7pYq)0_z=i zHJ7HbMX*?w`WsxEld0m1GL#77YtJO9Q$xyTDvYzy z%py4#%UPwYf+EECEXYp1?ih|2sjY9-(jhcPS2a<+WHj$1EZhEOh``^bj%JnOJ5B!p zcpXQLxO#@-k-VWkRC6b6!CBILpng5ASj;s)GqO0{>0`J8%*@V6x3`9O z1QIDFyy;aLPQGLKR%64lYExk8bYw&&K#pL-JR8G`a?ydB zO?n6b^j0biRyy1-4}BDh%71&gZO)@lr+4San`p_Tj;@BBLlmg5!|3Moo*5^AK^*fn ziBNP!a8OH@>J1#s@}(?|G%leSKbFCUp38UT zT2Yv*BoJst&Un1IW)+L06<8v!Ng0@tU>R&Kz8?1r8BD7hGjSvV97Q?h$g8SyhCN?7 ziWHJWW(-c!rbU%X`w0WF@h6m43W{k^ku)k}HDXKy1DbW&95kqt7hnl?h>M$@E_C8_ zrWH#zwkQ+K%^PMsokcX|m-&~R!V&|bybcHi`1?<@hAgMRqebV$u{$Zl9H%%=W6Kor zGlieb!#5ilHqP-SiTK>{Cb`CpP|yRendosLCVuJ9&bUf%<^~#xRN07VXH~I27uS!J z9_dlGkrI@;lS0mX!|*CeGa6y({b0u{E9Jr{@o6_SA1IN-`b7rUy9f8UUu~`cJrrc) zDI*$x#&c#JPnWW061ZE_)6!MXQC~#lLRM3U)Bxyh?*q6sk7Lg^!PHMpHsXYiimooc zVpxSnXG~VEs!FLPilri+cHGxsLhJPo9@r-cq*v+05kekK^J?(S3bt8G(#ua&n!M5<0)Lzi%u1vr}@6WD&rWI zGlteR9Q5Xmr-e%oJph<_WFgk%Toc&q&0kpufCjgh-Imp=tV<{V091PSlKp zN|rc|IZD7Zl=87y?(l$gzuA#2HlJub1{Yqma3y;V!$Kz-Zs9u7f~db|OtV*(=Ed+z z{60!gl8Ol+EvmKUs33a?RTl(%cp_!cp)^bc6Ep%-VNUh4T5bCTdji~Q#kjQ!os`qW zkv$au0EE!RK2guhP~-)~W2Z+1*pr5#3%A;D-;}t)LMwKS>TOd*vZD=Zd}j>9n6&ay z)hsMiaooOmzvNF15WFy?%4~$uk%oEV!Ro0Xj`2v!UC??oSEsL^x>L z)9eDHWt#XZYq3gdf~gxUpQLec2tuRyTaD7Sj3ScVMXmXHa`98H&*bUOH&*$5e2{f)^ zjDJ(HpXOaYro-f0Nd_B*${sUic*P7sln(+*Tpy1R+qI?Bg<54e(HqQiM^9Cmq+lkJ zM~<2)HM;Gl3T=Pe!<3VSA<==Wdh|O4*d`~|3?`mc#Hy&{%aK(w5>+NhD_ClLR1@{^ zhc%oHTHF8#r@zF<60D=>mP?YSY;zoO%rzrG!EoBEckTflxQ@Vu6Xo-zZKuR4t24Cj z*=50x%$}+NMj~;vsgW#3x}8sc3tF92Q0k_Ox%XwuRGY0RF@=qfiB;3j37yz0D+%SP5qmEJ93G7cvFQCai-Z}sFNJSAr8uA z`I)7vdrf$SJCby;zsJCyIjCqf-U6ZG5=Sh|DdY22EoY6r!(*p$Zq^?THahC312lqx zne!b~Ov>JTK5Wgl;DK@nv>W$6&Ma5kO_PokvZsOR0Z9+{LewAW17(QR>Z1Bb>S!BXsSk(bwc47^4e!{@(^l+yAkfNF}v~VPvQvU#1 zq{C~cMxdEzu8szzr-dwBQ^b)HNzs1D@5b~@Rn+GinbRB$;`JHR8OEhZDXA-9S-j#6 z*|4ff5)|5O%t05@z-oLiYlT8m2HH->Dcqyg;&m*&%9DG z+?_8ZjrI5r6+1s_PBd|D05V1t&0UFNS&EMjl5oJwQ8W~*5oT1UrvZ{7bJ=$T#!Gr3 zJyfMG6Eo9JxTKg~C4pAdRK~A18mmi*xgm^OSwm{wyMisvAu20@UfL@MRHme&^xJ{g zEmKuubhyqV4DiOJEOGw;E{di&$tPA;HouO%cG^{Q)gL-a`-)3L&Z}1{Vx~;pO@`H_ zr-q_B8?o>e1d>S_Tps*Bal9vmAcYlRD%vqTNtYGN z0}4;=4I5jiku*~BWqGK~IK=d_Jsj^^k2PgEv!$G?Ff4WVNjmr8$iPPmNa7@#U1teU zWZ5a&aV1SQ83a-?5XQoZ7XJVcO}_pkgWglDkXxeNk!q5kE@rxL;zXyfoXEbUoGDEC%|}L!;H3}swwqq(MpUn&%(0y z0Z6flBUPq~O2976uIR+vX>z1-fKIbl1`|cE){S|@F^Ek&Z%272^P#YC;f3_@7hW0V zh$3c@W+1?%Z%nZxU6-j^eZ(5dIGNeC3SAG6(Z%jJ;+jIW0wRwTxpW-83r$kVQArC{ z4Ysol#egmBVS5jc33X#ikl6{ECb-@OjGWV#v20o>{#p!L6{JOGH&-rqSPyvnLE)=z zCqxQDTUMy2?x>=+6HHn#Yas{Ckw&hv9pE*){CL%=+9^Z8MOcU6u|^J5^$i-xj|t5f zYdZ^)tnd<`O)hZy zs$3R2RiuA0;EF_=I}M>)OJ7eNHRFm*nof}v?Hy=*9##{1%{@IrlBzBVjn?}78al8QOt;W(j42lS`|!se?Nop&93FJ})Ov~JsjI9|qI^20p8WEi$82&03%?vp}*)LE3b&15alQ8yK2Y=@2?8ADHV`5t3X|W|Fo#Nu?> zVl?f5VKoaQ&q`*jqw@jW(TQjofCByQx?hT1ND4DWXLAjlZj^;c*;ZeO<}RLkkjWI8hb-Wq$_a($ zt)nxBo{m>0GC?*b7i3^Qk7zsyD6Y}KllGc9?nB8c2O1#Q?pe%vKQdx;RkSSB?owJB z@uE6ku-kYin;Mn#IHit?KO&-|<`!=95?n}FoA}?b_VCG}2^5*)W`}qx6Zw4fk;;oX#L<69 zE^K~W>2Cq1yiWUPRMy%cNTgL1W%EWONhj!KhCviaH5Rc6-1EsKihaa@nh~inTH0K( zfk_$jDHjv0f~|?{<}y=KeTsDDUu-E=yJZlG>!&QOiA6R!h#8+~kwA_;ZspnhJ7`Z5 zEvTja^rmUkI#5fC(^1hyDx~;4k6QO29g|NyB@Me+p+8?LHrAU^Aazh-npP=jaacDp zDpR~WP+rOy1+~5&&MLJqs&4T32%|KWx5;^OlkG5~gY@ZgPRN(p+e5T1}i0@LX>Tt|E7OR3N=Srq`rH(R=z_eu)w!&WqlZ@L z3RF>D(~3=7zv1a8`d?Y=H?2nba^&(%OJ40wSU@|w_B;;fB!DSxpb#f%rQhNb^!cl# znMqN*5GtNESmYLFP^x=tVnE@zI#7J5u)Sau@%aXOz6X~AzKV@i75jSX%YieeCAhswj`rKggeEan3QwK#>DrxVG-&o>fCN{S0}?%^!(LU@ zfH10~Z9&ac6!YRy)I}Qar;SUL1noPl3GvkS<1IZKX-{-XrmQkdPM-7%#9hc> z0qg*|_8nY=pkcP3VM;24N6NP#42_p^{yCcP<-%|lMohPcDzZIOSsSs}b7<_$Nwu$~ zhY20J3h<=(xY3ZdAOb}d+;YD#W}Nv|i(<;_hcpXAgiyo?h6n=|VHo;ju|C`1zZC@O zZU)-AWSOB}iD`~rimFj*bq{1=Nm?{4NNl{x-1|k*3z!6UB>QAuwch`rd(nL~p zphgv8(&Ln;ra4)KTKwG9Ov0K$WsLmYNgGHY*lqS6{3BauzBHoR18{cHH|d@|9d19E zmM~*jsyz3SpL;f>8-d|&8;ydJxZou8Qo}RiLZc{BVl%3@sWrof@r&fbKZb zQgv0-WjIk(^<9NXll<45wx8x#SAf%b6EEmX}Ty9A~wgP>7il2A~? zh{~~}&qX9{P(Map=T!v!G$V_yXN48EkWMvV@&wf_1na z2HFl1>oZ2k+2uvQI>}2V23cx%S*OCWIO-*6j>iUPFrC4T{o4x*dr!BEt>ltv6T)aK z&hk_xEYV7CwV+47b~my)+j2V_>3%-k5rrittY`3Ino4|=*Xhx=tht*BW{h8Ln+R)= zJCpl3Nxe@-j)W+G>3#YYmljlv0%__s$cAOTZ0s$T*a~*drWH__c zSrweyYVOi1kUc@*(P4R>C@GJd79h0sAd#RoPq_O#6K+X4Ld+jJ3+Jura3`vo@N6=w zwWY(Us)3dmX8GCWkf?JErAPJLtE+DUC7#wn$iF9k(qxi{1kW5Wj9S9YV-MP*<*pE_RkQV5-~7o-3z zs`Z|2u6^j)Nwv84H3h+d|wkB1+nYljWFLoiCs#;l=N+NusvX zjV^I|s#**`H6om|_Gbjz=+}P+Fj5h2Ur<9HYmR&y1d4r`DI4a?F z9$c7R1uRog%Vvsdd1~t=XyqCb7~jU@z~6=0gDH79idSIjkgBlkA-aF+e;u3Bh!Q4PL;F8rrZh_TA|2t243bpkT6?qv+Bx|^Q<-Xx{UYyfCVn=VyLQ&)(_ zV-G9UPg&+Of*xV!7>a^N?`{|NalZOYbXLDC5|DamCcyr7wB}k!>C#$wA{6u0OSOte zI0{OJJ;u^Tz4)c5DyFW)CWoA#Q%zHoXxdd_9R!CCr!!l7qfE43Z~ zX)~A>FY9JYjv!)-=7enTZtDBV{JG|_6IOHzHg%bTQIx6DXr4h8HWLw&9anG5lcwT4 zBeniKOc5>`WyKVMM29yONV5esQUz8fo(G9-bdky40+ZYek8cfH2T-Et#s;lJ@bQ*9 zL+TDgDOzbNGMT1~Ev>qr6H(gsHUj)3&zy$D(yY0%7Zj!SpNdyjbb~HLh+`ktZ^ zd*xpR#N31I>^L6W^qo$5QPy-oD5|8+^mF0RQP9?6kG*M;51cN_(l{pPxzK~j4&7sA z2AxNX8VWEfn6QlBkzC5Ak{Xy+pk0R40HY1SUdG+{y;!D@mBNJ>%Ito(5X30(nQAK~ zN(ow`j?)=E(GAr>DmN(auAD^EDdA3)&2zwO@d|v+gvN0Rsi|Z!30a9N7SB>f#Um61DBWXy9f;yr7zu;Mo=b{Ru5rnT zVY$+dS)ypz#XNGqyReyPrMJVeB!Dl?5hxE*x;o4p0!=PvI)eI!$~BPtb;~k!?Du*JGVcxqE+psg(Xj) zMAM{(7yu7aLklIw;on=EcI8%+vZ^H3JgrIcxuub$X{m8qNmM<*!7>YYSlIEqn9)5H z{iyL%<~ij{L7bYdv|-eA)i`eU z3_QuyC2Kr!gJov6(oO83-1E;a02^tbtY?i5IB~=Bl`bETVzEVoU^rIQ!7y}EWv-bG z)mwF$wL6)c={>*&uDYcwLOp20*#IY6{VB^g=j_?l3|A7xGc9Y^Eh(g;!swRkO+y@% zRPW`}$M#W679@>HxjOSmWi6ye+M;e0wHc&ET_e*RIw>4C%PmrflnvWi!`S}-$VBqt zM2d7oQ(kD6ddw3G!=RQ*HWSrh)pEmf6v<6YQI6XK?*3fUYw=;xS1Tk?1(|V4Y4ak` zHCsI$97vEQ?kr^rJO2Pr3{i-r>RcGB1d|G?#rj2^@RfyM$)lpgXOX}qK!!GE2iSkJ zfzq%pMK4I3a%!?^F_Bqck5ku4vN&-A3<@o*5;1>v=R>I$;F(x#qUNv>LswXFs{9WE z>GcjA?L^fWboCWaPWKWAo?@zXuo_;&iS2}`MyTrGQGV#wJ5f)M<8rixY9$6$@|cUN zmQ$~{TXB2Hh@{GZ38DW0Gfh}}KT4Y|Q&USpMI56~FV0l=wD99HHPxH`|y4~{{TNmo1X}&@+FQj{{R-) z5Ph~Jcj5~~4Ssa4;c$>eAUa#s13d;`!Yd=VtEfq(pL2Vbs1o>J{2Y1fOlGQ!r4&i5 z{;Mlw{ zTSXH*Q{xbP-PEeMW?~fYwf(moU2Xx8X+6p4pyNMPnO>q~iFPz@(9?^6roHtr)s%GO)Ov{r%~9i+Z1L0gZQsg*f(^S9rvv-m29y!e^P?<@Wlj)l|I$u+ z+^vSQFLdJ(mNr(U#3rJa!^LoUnD+P+%yiv`)SX^mI>}4J<4>JZ$EcdLZ25zt#cwSz ztHDukeHqtV4~Kq8`Ccv1Q+bu9;tg@d;iJph4+zXLvMI%@aoi>(1K*M=IiQv|Vth%I zj@}%z3MwR0H-JD2>7ZvXR;D9}%I?9WSgPDcz}w%Vp1|ALyNeVsq^+4VMt`C>i${iG z4N}M zHsTqAkpE{|I$Cqm`d@{0UsFu2# zdU)RK0?5~6yXs+Yr-`jvBuLmPW#f=(r=%D&FUYiU`6jCtOiq6(kLezCUf|eT%dZ`M z**H>gJVUOL{Zoc~FB^h}A{w5iYHUH(^ta2()&|}>^2`uH>8rfi8z}Hq<@#(ZqgZui zCMQoOFD^4K9@q-7XZbONnu9RhI|BPp30ZKd^?6da0MY^DM1QGxOJWmYQwpOLG?7g6 z(MB$^6CK6dz%7q&hYl^B0%<+NWW_Ud!w~-feG7$E!dX_XzA+)uOk)p`fduKeGX2Mk z7Tz;Og=A9>W|k~N7{TEwvLQPpDo*EFV`9ucu)|(B(tJ48Nydhptt3Lezj40UppZZo z_uD6rZ8hU}8!5z4jWuLr5C$*P#2BHZ4`Rmar@N>YzPwDd7^eb=HJ33{F~hS}aiQ_axFHiG!9e`BB{LSmJ zXsU2rPK0ibu9yS}*B7zZRqidpy_M=6OoPIMmu-~bcF?z(vh8&RUK2-AV^d96EcISc zx}wWTMKY5O*fm8r*$4apso*Q}3if zo)jZiPSNBXy)8AD`93dOg-#juK6OW$ScBM*ZS)Q{@7`*b%YZs2m@4Wes;sSbm>F4E zGdTzTr7UEM31KNA_faP=mTC-2K)Pvg3AycYz+UvY zbfzdllQSxc9sOa7EJLOpJB}#6VG}hPnz*4h^DTr|$DsqmcM$G-r@UC{A3CP+2ni;s z!>bkTEZKOZC=v>9m6l7J&cU}9H`eCB4~HZRQGuY-svyar3lg5BVt4{V;br-_l^7-V zugqD#*TVcbXkcj@iaLcI>Qf#S0I6B2mUcu(YE=(pdUs+2xFrY%*7$I-SdkQ@2&B5y zt}Ri7VpOfVlsZv4jQN_z3XAD~4qifb(;g=0kP3TS)F2~gc;y^ zf0qo1Uge0;jV)je_-fIFNus6WvX`;ZiVA6HO9yEKNmf-zUoz(QxgEQFIpemrgw))< zjZt7Y%x{laP*Xu8%t{hhbg^yiuBO1-h_4b#FxyKq(+e|CnRg7Q>K168qYm?_a`K?_ zYf)Q$$!79l4`5$v-sIUvr->KgPhA=n0BFJC_#PJ-fhizZ=rAJ5QqR(cynPUpF+hq$3nQGdj7%Y=-0syNfwzte98yjBQ@XZqx)J0o8 zbWKN+b5<7(NT;c(!!YS2WY9_)I(IRhx)4hMFQ%LdYaf^fD8YhD2B_~l;&oVdd9S7v ztwxZ^O;H=OZAq-;7X!rJ;P7t4X(*9Iu09gvQN8M38C8qqZkOVa(zKFEhR9Y~*o*cTJNd}9{fGCPP zGt-)`o8eTcw5rkJl~E8w8+l4eupbT)IfJxf&xxqoD6Hk0#f~iZO40;XmPofYrHetj ziO?j~@fW2kANn1W?cF(z^|Z7^b3mO+8lGrjVp$s~50cSF!ha zmn}}-iZOjfC?v*f-0<4vd0)U?|)|% zG=LRNx=Miaq~}#CDIuk(l^jN+-6gEMk&c(J?Q?q%hc|8x+OwcVSfAk&EL6QQ^(j$B zA!!aZh7^@`3g61zmcVOmI7huP0(vQCNWU4c|Ifj~1!w(rwZx%wl{hTpn5{1$wycFV0Y&6H}GKyF#u&I7i%YfC2bd0c*V0a{mTHVKD z53~+5V5ms~m0mOyX?xS`4Mg}R8qMTE{Kk$4l@{T4#I7|zpD4E}mD}PYrh*=_QB%j9 z@ET7u<_lDLkenJQuqSq{Xdm@U|L z?V$K^h8qB=)vs6LPgMc<laixRkG@rDF=--|+uQcTfX&1zi%@_E%gL!pDr4NV14no8X2@fFwpLE_ev;3uY& zpSq0JREnGVy;Sui>sZ9fqH5X+=Lw&4IyR_TAt;f~@GhXi`Q0LGdqhnc9E_EiC1@hvL5~;(gW~Qu& zG<6FcHG89wopu|W4{p3F&n!~#N>0i&%5K!rB|Bz~rdXG!9-#8Xlh7xTnDXsdO6p>s z{vC-24-7I9s7W@TDq*92lkaK3YYKM3-tA|=b{Z7jS~q;xdWa4Uy>wT4?SNNN;@O`b ztHRC*hY)$Gs6?B*sQyX~#^eG=n2&A^ZQcqIwt*{bl}YKM4}@Y5O`5To=L2v_8DVRW zcog@5_LHv;5RV9oam7MS3KcX}6ohMoBG5(uQX0BNI7gYrlV@M3Lf?ST^5TJ1@jsWCwuQ6_-fk+%k)kTWsXxsFHDu?+$E5>u zMGhZ`NhS9Sk^x_hCS|dStzAY7jZFS>uq_)sC3p

D(0NOJjJ7q8v1t+5V*IRUqRz@--hTfuHS%r%uZz9B8TZIrSqB?=Vwp{+4W?@%~>BR&UNhxu;; zP=P!!?SCovGlKgLn})YOJVBSbtwb77`Z_3+^!BB2?A2X~R8mJOQqoMw9d1@v42X5? zMel!a1n&O;a~RPBN&w9`VpyD5jePYRS97yXAVahQ?WqI8{{Rj&j}8^$1k}uvmvP*C zGgrunl=*flWK3$lU?x|TRl_>d#u!cn2O$Ho8oIum zQYwrtj*f{Gsv=&$XhQni-}i~`P5d~cF||V}NEDH)g*dY`jl^j1nuAL&{{SLdRGyNe zozTY7l|E@UJ;N5Y{uc1!)DlHe!79duOsK-D4x&&)qWL%#T9PiQ{)aN#LGOK&#P6hl zBCLc#j;al)aP`E4;WJ{6@X@T0Rhu2LlPr$P3GARSKVKA+gwV?$Aq_QhYw8}*dN%6DL6F@m6-Nurl*L#rKqYfMcgD*>V*9llH4?HT2d(; z!cH-b2wti%YPm34I7h%;#{#>mO$Z3uFwiWpkvbR6HSj} z74YH!taS6z#~jDHv$+fb99fvI0HjucNt#o7*Qb*W>h58~QX~AXfzqCasYUm+i@$BY z7rz+E+|=CC+qD$oNdA&lLl#S}rKm@VDe4QzSMC0eXs>H{j}92PKWRkZ_-N`&mW~mZ za=tw#ENX*p#Gs;hNR?rZ(x67%L+)M1-S=t2buUuLqXwHLGeA97Elo#9m1sUmm@YR? z;pQSBu*q1=t+V$?umw)KpJx`dj}((MiE4}@l3ie-kUaOP6B!D!r~}+>4wm)}IeT}o ziqpue5d0x4DlpENdXY$A-BS6F2&MB^TPeYugYmH^ft~hyPL8ogd#`R3;<~H<)IoZ| zinf=hIW`)ahmuIMG?fVRn-CD4PP7+3r3ZuK*T88DTpTiKWOvLNT&n=6gFp!!xd(G!Q-lS zN=zz_o`=kTc!o%t<40MCwB=f=Hx+?bg@h zB6!ozC=pLRNX!ycWSmth2bcVx<$+}dHx`jBb?!Tlqm@H`DW+X?ltl!X-X!>@HPWBa z#?=)wN9K`m!CGk9R_Zjqr(a;=)`1CCB2tM^rI%SFtf{S3l7BWDX;yWPVxwUUH9_sM z79KoC!ax+U*HlFb{XAp*!ibb_myZ&oLS`yW#4Jx?e;)j8%p}w8D3d0N_fawEtGdE) zFO|AdKl2ZqsJ_RQm{=$SRRgiUhl^Qj_A^Nyd-jA$}} z_0`#I6_6+*qpD0Ir_PR%Drl)*N~fohL#wJ0p##0`+nOsU3SZnMD8{5=SoDcS)H;km z4c{$kr>QU?2^29%wI_Z1Dyi+q6oN`-i`#ICq!&*5v6%XKj#B50t6LogC~K+dampIV z%TVI4GWoeC@~(A;?R4$ z;KdqUr?@3bZBuckfbomT4$_+_Q(}5)B|{96i176WNSeV@x`OGjpAT;+6(*Oh%_*97 z>eV$X<_r>8Dix!rX|OLYJukABDWfD@*piKZXDMn33ai{Z_IZ9Zgh`=~7`##t4K+Mx zb;X;{lpEiUwAK`z+(DYMMxO_#>25`*dAy173>q4QiXr+VFsYdX6W-@$xAEZ%$WpEq z9W=Jl*kl7myAx`;ae6r^mhXfLznWQ80tLLWbM&^nFl<1tI^_wzsqv(y$(<*JG4r6x z0Lg7XN+}~#_1tlsv6yjj#Qdop;)z0NfMsT{gEQcjP_ULtg@Tp{RkoHPi#QF~Tps)s z5DI9GM1zH0=b^!bR>jo1+U#0eU`>$ZvDwpd5}jrLmw;n#d8%U4FySSZjLN76D+NB-tTktjy1a=1*mm=#Vy`gN>E1H zA^k+eCyOmovNfh_t5=5-VW@>G!l4<1#mj}MlFz3#3hcFx{_I%sBTud2tmGw zw{98)kb_8^P?Y)AighPBU^vx2U8E)mYN;vG8mMSm%Opss$PI_Pb}l#@wqas==<4Of z;TtI<(MpUeo@!dCrvH8y@1>6)xdt)ls#=tV2E7c;hCnx@wv#WMooC z`bR+8Yo_z`TaIYJnofnv#R|QA#YPV_xK3D=s7#n{8NPajX7eRdQf6)53|Ig@k7o<) z5in0p7~I?tFf>u}mLcb3ScFo^B+E%i$uh!#Ngz{e5Pvc_A#olNM4V}T)2yjcoblXB zptP87UBlR|b$cjjr7mui^x?E=TSIfAFTCCWqPcV=b<(y_O2DHrm@^hq>AqUS@hoYh z!)YWfL6&mf4x!#ngtOayivYwKWjFVTzkuNi8g}Jylj}y(h7pLyi#|1+MtF6_E8bVx zGdrwa>PJbmkca{IMgIQ)9v|9ThJ;aV<;g0cd(-AGgy7gOP_c<)T7w-vA4&4EI-pj0 zYf7=deFujSW{j!LHG2o*Xe`h8<`;>yaM8rn^;m;cwPeoMl(o*=kzuskPot09GGaO_ zcQ-iAD>61A9wSel<65y#R3OX1tH|+|kLBva?odaH*z<2SfUh%fRHMS0@S1El4Xdcb zscPV8=3^~NEY~|^l%$MK;?~%pSn4@Nf>Vt+$i&j_rV4-Lc;dlVAInN3dU#ZjOmWjd zBkybW@!@ib?-F{b;2#80O=_vJ?AuN$OHCa-ani)hwz>1z-rP0Q38KWT6IK=1e7RSN z^sh1Icw~WBDotu(Oy8xFCaIyNxdi={Y1-D;zX)v}33Vf+Qt(QeCxA3abLJ-&F+CO_ zB`&bIk?zCY^0p$ahieOP=?H^KW(6Dkn}@6&FUk0jsY&Ckg089A+VaK?bg_WL;!{t% zP7~fHTr{f1$wBj?SJn&;lMw1fZJZ&VlAdHSgS4V`dQd_?ZVu( zM7l*Px&uHoP(43k6?kmfdmD;Iik3`Q`DQau8=E9TAux6T-$KUUM-H!*gi$gKNuhhz znmnCXpr%MZVxGF9YU+k01GXvrl(`-38%`q0@NCZtGQ3oPDH(!c6m>G;qWM)qb1- zdl?>Rn46D?;?|T-CW>8b14j!mW}GcLYlCGZ!y=M=IU|;n6_rSG?K6g8-G~U_Sa<>B z!obya4egb-Xs+x4L{NX!+|gAY zDNlx=T9{@xfUxq{WQ%(O1=xZQ-_5YdiK@Ke*;YUJKUGfoBhQ%gA?Er~~3C8z@B2&Q5z zFWj>D@yA=js1`w^5u0i$&Sa>qkh5-PiFTWk+Z9E{kA?N&Vp1UCMq$y$gdCfNOIJgW zRpLzhBcNuYhCRw!UHWO5v(%nsVzFAuSGD%`_4uf>|Q@>vgK}4Pg!u-9u zWn#AO2{at!9QZMerPJI>5S0+7Ef^@kgQSa2s!EH60_W@E=Ng45QZ&CH8WMV+T~~ewW!IYPHV1@1;emM zs3NGXcI(opP~K!`!@Y(704^(OIFU?FHPktll*p1xx&>%JSuDU^SPNVZTr?|s$frp0 zs!FWGl^Tkn-Kb%%nnhP61M(6mJ{pVZ$|D@sgI^Xcam5oQe6BuwU5Xdw#V?EpPgd%?H0MYvy?qEah%=fy^!1J4;<+Y***KbOUUnov! z!xdu2a7mqHuEOhCblD-+NJ|6dOWcojj^J(_hw}Ggd?$`Sr7l_KhZn@j@9^c*9*y?Q7ci;HfuF+$bxJ6D74FG0 z;*}KCID@-;vBK3WxsI36Esq^jSQ=ZeQbf|rsx3(M_=Y=A62%i^XpqL1vP5YNclaN6 z+-}=x2A)_7Ks^)z)MI6{1xrQ?PDPOS>Mbk6pTt^hduveb2sriG4 zqHf!{WZq8eds&I%_S+TZs#A>&{;Dw=*{~j;!#W0}lL3l`DI#>;@3DZ3Y3v^!HsPg}S_6$?1xH8J&DEl|$!yjY}lG`{uFZgXV-jYo0Ym9{|8YPU-9gI!_um2hTE zCWSfyF%n0Nzq29 zz!g_7B`E8yGRl;2qfd)xysgt5x#Z0nEU_!nQBqPho>wh)jxOi9ypo-MlWqqRh1|Ib z*~HL+X+^q0R^Am|n4Wjc+4HCsc%Cm_TvF4R@ccd90Hr`$zx=9Nb2>1F6=G}!?tQ(_ z1+CbjhQLh*6?C^AB}SH1*yVm51eEDI$pqtRKyJkLu>km6PBsyZKI@u=3EdvW<-{P* zcx0AzmJBugpu{+6=c*vs3tL~06W*f%UbS)!X3Y6kzMSFHLJNw9nA9$tkzz&rU92wW zjIv~r6yvS&r4~-0Myl#u4=gDpczy*eLZk!lZ>@~jpJ*Q5S@3iUPTcCIToV|EgBD{2 z3PV!u8x=wjJd6Zv#`gr=T;JKszK;l{Ej&TOgkf5hmriI@EkF9A_W(;q7_G5 zsTrHh=oWCPxJufp$uQO0!Ik#cLsB#(UcxRDA%HFuzRQAK-p{ErhMY%g^qm@9{xG8Nog54o2kxE@~_hM)->5UE_M}yD|IaT43c`E8; z+qIwNsmLL`PuaEj`|6b%Z4BW&X{XgrHva(E%)F%Tl6uK$>Yr|cD9}tn?`yX=m$l#` zt#szdq-8cW5HsxCx+vpvS&Hr5Q5sxZ;ll=+#*3d<3L7z8LRm893?aPp<*vtf+%5*- zNFF*Jc$hQ_tI2SL&jAhP?yr~tr&{yB8&=-i3!l4~ z^}8rgbyLyvspC3vDrr7{BU<$Oo_b2G{YNY>x~76EL}CVkLKZi-B;2e*4?#2$y~SQs zjp|-zhO;Zd9AGRFPfH+;1&BcE+WmZb*|J=x9D<4naLmFWs-bjivECw5FMF#F-y88$ zjT)eEMI6ek$u(4=>flIPYQHWy{?*brLz7{ryiJeM!qCtZ`nKaj7G2L1)p@jaF0J!4 zec^@<7GG%CYHXWtKp-9XO085rj~cuqrTEtTkG4m6WAn@1w8p0 zXu5RY5{8qcnKpVT!_0ALqaJ7tVD({bZr!+W>U?Ht0*DF1gwCZ`SILWE7#2B;KzicU z6!f({Jg5dm-vSRSX;Z1QZnf?`yihOO>Bf^P)!ng$16kJy#=2FTGVTYRDcdY#xV0Sk z%^n$4LrEmLj5AbH#9nEcBVdO9{le*O ze0i`dPbiufx*LeKE@{lLh^3Y$!}dH>g6v*8n3l%>0P!QlSN{NLr|i5+!ksbP#fuDH z3_1pzeQdHr3~~}IcY$+lE=PVa$^k(pls~qHiaM%?s;)SadDxXMA4yM9Bew0XwKYyH z@GAOoE9d|ZI#pr!8KTdbv205ZO8OOw@=VWAwFz_Oqp`o%3DfD~#v2$?Rk}oqS@goT zdd#1WN3@_waQI`9ukRLoM&#eQAnEsVmx#ntn+!>sD7f5DK!*#E7WsTv&vsjuJ0w_z zyf1BdY|^B9Q9HzghRQJcg0_0s%=I5GrV54#TVUBEHW?B#>3frVo-wBp)lVg6Vu5~` z^*cNCTc|ibX~`JG_%=6#FliMxG&L0LptLigHj*bFX;0EDKscztn*75b5R8r8oubb zM4DMi7WS4N99s}5xVx;;p~UeNe4mzS9~D>#!n~)WkS)V})S!)gECC!VE&kMzMrmB7 zG#FvDi;Lz;TtDW-h2|Au$L<9}`g?8%-gu`>CTfa!L~)^S)C{kQWeg`0gbAAj!>Mbj z)B-?nJye11@$bY|BTIyI)3=bMgV9CGw-d&qro-_nb+i$~6-27cM(vUZDn2$h;kb$_ zbw(zwWlRVfffl*=>a4%U}n_PiKb;H(}XzW2@#U(>Mg72cZ5nN4dIc%r1ix znw~AR@YK&*k^bmrm5!fLC<^)%nV^d+W;(1xI$#Md)`ZkkBh$aUtg=nFQS9NE zWCqWb7b!tX6k)TbVWxU)J_$glFe)T!tiTJ#E}$QXJT7TC(Sp_zF`-i+J zfrXX3hAU(29A$+7gGw%-s~S#>ed@8?DzW7c^Hr0Tbw&5rW2MJ?jWqaiN>KtSG}50c z;P~c#%!WF-B#$oPGW@nBTTDMoD=;9_!Ev{Lz6+D04NkTNmmNz$^wX>~TvSn?p0X?# z2{>+5!lD(__lpn0=_Oim<)|Lul5GG#X`I}Xa&@raS^KiJVsPo9J-x1k7!qilX8xY~ zfz26?dcW%BHYJG7Pv=n5(c)CBkfD7M0FuhS&Bo;3{5-bKY*;`6L$75Mzm{ISS~J@$MXg!km5LO2%>7(aVi!F8P)Dr%-jXMZQ;d>-diUU0$1-8%NwzJl}SnV z8cAmwoM#5cs<29!W0Mr36!X;3Qb>|CX*vl|l7x*x1RLA zQgZYvC~B?6D_D!7hx4HAn_-C%+Woq z^I=ilChdu=wAPSfj#e8|#V+veqv(UKNa1 z&li(2)KOuK_5>%FJY}@{Na2RcKvy`?oWwCDj|8Kp+$ENJXxPDEHV`$w-(c@rFiL=xZn6m0uDbu%$M}yk;kk3CxP?NBL`+h$c)Yz;QE<#fnCsY!fp3o>%#pv^ zsC9hBO*hL01J0-~JY;-FshOoDz_7DlJxv5s!mZ{;LdFW4f&d4{UJV&{x%OJ9re#TVGT!vWoYPxhBjI2rUE5EcUr*i(~dQmwuMQrF5PMnDmGmFHT_CdVl>je z8$$HdXLA^4V{Hf>yN!9bw~2rVr7YyHEZ`{Fk)7i8xZ%a(AK)bI6~E=c@WCr(DmLC@E^HVX9assh#5qEU3X419B7| zQs+KqFdqtH-zs)-G&l86(5I+=qfqa|aO@g_q|(Vvw-KwA$ua})0}wvwzY|+#&80w) zX+!pEP=G}u@)zN+>NhLoyfZFh>3~<&QdCD*1k@EZ1rEtK_H_gu55tOXbJP`*5B^K7iiHfA=b~>=)l`(pOO$ZgzEC`r!m4nsBevzb5DmO+Pt(MS&Kn#JI;%Ai*FgSm z{5E}EV%Tm6jAiVpMGN4yUp-kIc$|J~8#HAs2pyXIQqF&EsLsktti9e8pUA$HJx^sU z^@U?yUC9-Az6FG0P~vnLeHJ4NLg*;kbEW^`G-HKtt ze7{Ld%PDB&q=u{w)?hAt&9?7*@pF0GI}IaEi>aBaaPD%)>QAMj|CRn(PrB)O%OYhTrJ?BDKCWj5cMULXqIeK zC!^vM{{W)KAgh1`VeXAd@3;;lb9-#31rKd6PC;_5i6({&kLhpJwnnbR@eDW9-DY9M zrdGmh;Cx1i2vkW8LdZaCg7&u>R()vx32+};vNFfoGEzk-qx7Tdiyh3AnB(+0=#vkc zN}7r(F$jc(N^BclbO!dl{k*61W>T2dB9psh_{U8tF^-J&&bn%5p_O#E?*XAB5R8RI-?z09r1@R~K=gfgZxlv6&^W3=!^UxL@=3J9w(mn;XZHB0i(Lz`lk1B))o=Mb{24JVfD%!c|n_pN(y zZX6AryC^u8i-4HInJ^Da`Q9puitINn822n+B`sX&9Slrf_7~Sd$If`2FlmqFu1tYT ztaH<^RdWs*T9RNCbk!tAuB%c!#34j`+rVzICx}MyTcuxcrN7BvT6R#)fpkMW(PfOC zmN7aUK9wjK;}r5zR2Pxtl!cN^y$>xY~k|Y zIC#RLrWNRfmXcCIrd`Y3LbRwsqeESRO@icFj5DWr6nLI3 zhDR*~R58l5=<)!pB3U0$g_v(`SeuisoD5!ONbezPfyB^`%PmlBsVF5}B8%Tdu$=RU z*HY(Rvtxq|>P{avFG*Q|;MEN_9Stm%1z}Z%K>HDZs^4FJKbc?JDJ3lsQyXj9c3*fQ zZX|=zM~5L}c!-XwNHK-RQQXfRJw_cboPmjA0~8EbTil)j-eDx|p*n5^4-F}C{H>ZX z+$ysMj+mOPRtae2n+a)RQzIh8346 zahlW-%{27TQdiTu$xP1CO(d5?DEHU&nvv|~)t}p#8ijanz1UG92iZn0KTTbF%orG} z!unr7^>Y%9L|C7lACo4i`-2i2QiHhDP9j$ES|HA`RsKYQ5<#22Tv z3l1?&NdmzO#AH{dX{-qkwA{)#r0*rBpS(=cW0gJ?I!$qp(KlYO%wlS4+^bbBU_0TU zo}!T@mNimA3esIcKJL71?lO_LUli+uD@X`j8ax)8Cs_o0r11~G|0OJ z4Ll5Xvt723dvS$l_N!C{i4@_=-$Y6@*7Y_ zqTDe4aM=`*HcQow3%FOJ&Z5Cjh_*RPIK*nIi_uX*3G$;xO{6CD9;K~&5%N9EW!T(4{ozXHfXNIFqqd7#*0_OQ}bxTo~AZf!nAH~K}5g1 z#cpRHfCV<)l2T02n~(ZK>qa+}@N5P=u^m)dewXE`sH3Qlb4w(9Ue0VSadCdbPW&o4 z>j+uYVvO6faH9$b^5>wQw&kH)G0X5sWr}F&U`n07RYb9r^2;3v2fetkZwoGr4AM`? zxRrRSE_n1q){N7MR8~ckV@9Zh$Q6}!F@=G<6(LDGfL<+YH*F$mm#tQ#g(RW;I{MNu zDvC*Apu=jbBuUbDGRTO)tKE!3_qw0Iic_AVc2YL-)to8XUqW4OuY(H1PANf$)FPyE zRQYqr-dd8+WCr%J7AK7_JVHq@PqLgjQsZp_`IGS6^%+Hv3d|!l;q`PA%@b8oO-Enn zG;zwam20iEX!W-Y7~VFDV5E;_GVV;Fh#=54n*RU}-n!v*mDL!HT_kArGgO%5q_0wZ z*$j$`&Og>7{8BfGum&FrN^)loG7Va1;MLPCccj^0)D8`vpjuo;yEEYR^ddEV{##(u zM(TH4xwXHiferV$L(6GHfc$9JAhug&z-#}|Yy3*FnyTKOblKpc7170AUsSP%2$c&a z6IRB|z?%efeLjvs8@F&>bc3=!bv5R!XhLGD^C#xanGR#aaEh#QlL*Es@aUq%-g?Ny zGVXtNRgzM>mAhWoxYvUx?bjVR(OV9USm8&fAmVvSMY88?9iTDqkA5kKi?9HNH<%m! zJVfJ4jg-5+PfZIL4sFTw_<~U;Yr~o1Wb-ML5}?xKL!{Q$_tfyM%WYgJ(%$z>5Oz@A zg=g%&MNYGSTJUs1w`6hRv=cHn{R^9gk2IwJ01YW_>%AmR3|J0u%UGbLnyWuxwB}S% z95tA}8q)0qn|rkfz+T*Mx>RB)x%VMjL8ltre=O5g{{W)q>>{EFY^yvNz7&eZfHxuP z7eRhq2|X1?)R37bxY2bZDA7$Ebs47z41(fW@r)zhuR(OqEI)oFpRihZgK4!Y4iSH#PLXXK`tEloh?%UfLL!b7{geD z_OHaJFXB^;Jge1_6BL|$*^^3Q3l?a?rKZBzM%4nkk&G-ru)4@@ec{`hEv$k7rx2qf zu7J$<>JKAjNn@g+#URJyXG(c6>?H%|)?WM`U3_0tg%VZ##G*`1< zseD$KHPOkC@G7i34w@zvvf~xh5UoIWHen3&ivg~qzi$pdZIs-E;(7Mbt4`YNDhHn` zU1h$wQD%r?qsQln2su_a23>25J0fyRx<8#F8%B}_lC!bnz`|C#2DOCG^3d@M~ z(+|p&F}79DIA&*e43+eF9c?VnD=LKmw6cq9r+z3Gidsc=;7_kp#v_VG)Ix=FxKvXR_1Z5S)#O!=c5 z$1CwXQK9SJ1BPId0X817;&>}T2wfRKNr`KL-{Zy~wYqa^J|B&4+V0h`F~`oDGgnx0 z_7Rh?tfgO=aLi{Kl&Gi2aNI)=Vx=3*6FSFG!F$*P;l#+wE(h?K^!#Z{S4_CQK~ySb z4yt52j28u}uFd#;Ag_%@S`2cAUn*o$&AbV20_{3@@XpfFK~S!}m!&%skxs*D8%d(ugo>k-d=GQ_a&C}KDvd-+0YTyGCD z30BNl4>tDKURc_wEA5JLE-O|hl2c|rn?Mfi;e^7-zGJD!F!i{wAH6rka_J;t7}Zn? zlLu&|l=-`+70}5YK6=7{gppcf#&GExHn(H8V{ZODbMnh3Vzk?Z2d0o!dCMW-^TAyX zY{BZGjE0pb#&E_KBrc%O?*s7ScdZqqk|@gGGSz`GOcUlTm6`E>=RGgX(XKy&qT(}u zF07}XdI?xXBt`Hy->@Trs%QkR+lSd zlqF-uFx+OUng|@QI~o}(S$9VziA`=h9^5qU`YDgi6($Z8;N3#Xa7iLAXTbf^9o2Dc zGRMZ(S?#U3rASn4q-NbGVXiXg{FLgoQf6!#aV^p^_{J8%-*W4D@AZ+!t;&JfR(8-U z8QDoQ)NY&7s|j;%4WP2dF|0L6Bk7-B+%p!W;}nMBdQ>r_o^R@2NSh9wTN}cQ`F?FQ zgB756Ww8oL6C19)M{#0SHd2NkNIPgM^u?HPgwI_@dMdgqntV>D2a=jhI$BzR8;_fa zq>BSSpt)ejh4%>!6zdyJ7^rImpzNtXi1k(?y*BC9RMd3XmLExv($3J;F{hBS;n;(0 zM^zz@b&7^Ik z0at`{+OAqUtS>p?l0brJqppJ!pk|0VsZVsvwSXr4O8!vdIAUt;=4b+G4VSZycB7LO zWT>L3!DE@Q+&;FIAa|;nMV=TMGUKrY*yw{^Fm_vXMoMVl}hFOvVLppDjqW41lO+_n3TcZ^OHX!)UzR#= zE?%U3R};bM(jU^%VUuHcL~_Ih!D&lPeOQxYt*m$ycP?A_s2^<`{{S{kvW9~+tZdcN z9J4MWm~=P|WY9CKRZ~>qwX#aKEwnUSiMhD98Wt*GY$w*9cKKHZbqso`1)Xyy7oKqV z=y2>BS{j)X$&lf7G14cI<@wB~Yp%ZSg^zwG8GD~~D6(1-VMH1o=&Gskd?qO|8EL6$ z=}<^gqPmJl-m79ui3zy-xu-JnRTQVc2u#fv-l1l0n_?A$o=I@*OwQ<)Ej@i2tVl)e zwI$uH*XZxY)s;Sz;T-#EUA|`0c9B80d&DwM3sZ#Q`F5_38Bzq3`PB7zY|%un_u34y zTpKQ`c%jU>&;$cMf30X|45(tE?4zmDjKP+%Y&Q|6%-vec*p(%0bk%}5@vJ(UG?8Oi zT@WXvO^5@vxmPmFi2F}Iw7t8laG2C1o~jz@I<ac&WGDR@6sU6{T3GSKK}Hu*w~5=_X>Ps+TWk{3fNSg3a?4_>C1ezV-kpo>aZA z0k!+vmRcPkz@}emC_84bV;xiJ#vvO}VmZSDGlY^Fq>C5BuNu0Q7yUi0@V^oMQN;{J zKFfe&DLp4qa%b|%5~n_3kVg|k0#Hz5ctgLGHe23#$*|J)@a0{xbx49K?)d>yHqeom z`j3?>%sYCYfi*J$2ubnWBXU~yAMZu)rx#n|vf|-7t0p7VJgY}CPd079@VeDd z94<429UkFZ{pdT12f6U#hf=gB0W{l13Oi{JjP;`;ts6s^^R5o{lx11vpA^E{IRihw zpnSl!z$bw_yLX*9Ap59GWR}ylSbEYo81)GnQlX?w2DS<}iV2NAH-sxNKKYQ|q@S~) z(?iCEt>(ak?)+(3O`-n)Todb1WA!bTjw6R*Q^Q3Bn4Ls44_Ov3g)}g%jugnnrct$T zbN!q)w|47cN5YZ4XKqHIvG1X|^L9?E8!5An093Mp9C+po!L&M&^FL1nX=!n?gXt1> z(r+3}hh0$yB{pclCZ3qQbWSns8DtxjUdB3`kU-Y{&Qt}S6sR-;WSl92Y;y#mj;=gE zHQ+Vzhe;`y5X=}=kw78!^T{OKTZxq8$^IXOZW+`(Um8N=xq~iEm8z+;UTn+rEl3qK z*m%Y01H}+xMcdCHwe8!9TXFXiJUG*?29U1_r01h7Q!ipz{{UL2!LtQEVxy#KJg^Jor3o z;8IKn6PT74BH^F_Tfp)L-Sm#}QMNu}rknR=AR5)L)XoEk{{WmZ42-c&B{ed{04g>z zw3Y==h3&~RDqN!;nhxJ5$0MSPJzq@o4kv#b)Z-0jk z(()2OI8kDnIKiimkMut?bt@|MBNl@btfQYOJv~ECC7dHJ*$lDn1ZpmZ+-Camwv?PU z)$A>n>QrZC1C`O{T&Y!w;I&nCP~rlp#q&v1GM^|$mMQ~V-a7EaA+><0qOi3$gql>- zQf7=d1Ctb{$LisRDQW4Y*-M zunlW!Plpb}3DbxaPHq<_4Hz7&)7sqSm9VPx#U>clU42FyH=R{buEdmOxQv}F+%A38 zp<6Jc7MW7hwt^hbm2*A;)Hz7`#T zaHA#Z?=p02C1QAuH(jf9B}O5DW)qBHYn9`YrZ=Mb2vf_DnuvvryUPn7r-iwr3tlaO zvm6B)<<|*7R=Ei(_QA4S<#vlNoAEM^$xrIu<6%2@FET+_=LcwDNi-IYXsrgI)i&3V%TuIScp$1zL-ii${TrOak}YM5t|wt4)ZJjS{x zkQLWU+k?!a+&0gqPMx*P4?rPqlN5DdWfQL$2p#F`3V!1EjY!&BB)R8i3G zsHmO^r7E#3flGa^-uD%&yPQDwQZ+WPCQVGucy>2|R&0+Kt%cp0i>+jUfx7GNhSKAd zWeDgV%1-j!L6A*7WQi(jXtBz=oJyuyX@qa(y;Q&vyc5}mr=ESJ1ArLyQ}&k%P$Zp{ zBjY(rrx(MY63aDsj1{}gMx85XRAHlT_nWfb{7wo|V1Y`O3WY;_A2s0^WfmA~s#dbL zSmSz#YNjk?bF^8*`1j_Mpq+xNBn(Xps$x!72O}uMk?_3Wa6~Azm zm;(VuO|(!%owdt0(bgtmsg4@yVt`ZmGE(ngvAu$Bw_)~&H*cd(BCNerg$SOUaje&p zG2ES;GQMG{!ZS@BRa-?;vbzalSfx`G%HHgeNIudqAn_h&Y}{F#4wYqDJ;TVM%%4ZxBG@#EpPLo=y2A0T`G|qLBnVb!;-4D9fHYPp0F6Hh6{3l`N zXi&&S(ho?geCrpaoaNGfpy2s87nZKOFW19UTZiMxEUO(*^4*bGsnNh4kJaJ;_b<&* z^C3V9=cHq#M|j0RDTLej8Y~{gNpfWQ&&+`CRP;!No9}#3BPOj@$G3aBC1<4 zG~NAMn-QL>mV824Af{`@zD71Ipy_kVKpZN&cA7I@ojo*W&Z}e4S7N!Qy9MdK6E4hF zvX*HC_0Jg%@>E*bNJ01HAgp6k?`=|9nBTP8a2WH|O6_gjTDIX<*`4~KlX?f!s!FLa z*y-V-rfe4{Wn472>4YSdfm!!$UCvs0n3gBGEO-ZLgRiQ7Pc)KJlSxxkEp%}iUE6MgNduBTgT(GB334D-)2T?IqoA2{ zFJL&9SA#V4{{S1sb0s;d!mCaN@~{U+ytfMiuSR0WHlwb<~s{FNUJN06gS4FR}Z z&zYk?jQWlA^_OX?W5se#Xn|-9l=Tk{GROwW3`{NaLgMS+iIHOA!~u^`rHH*?5)@)O z%?DWbU;Qv=JQlW(48k*A8rH&T<(cTp`?D{-+N(>CXB}@Yd@Eqbs8tQ^sZI*_njtv$ zRm&Lmd8o`;GZMt2%Hp0Hd@dYbSz@XG07r}Eo7nTMrS_*E?hLgKY6O%(7YP*t{{T;eVXrZwj+!h+zsZ(B zPU%|f-#|d)A!!LDf$XcTN-jjaI+)tPgj9_EcR%|z3>QN=wpjVy=sp`QDR zZsc;Sxg7)9S3_z%Xco=cFZ#8O2=Q!oSYBA!78oj=m6dxVY-?Y~zYJ|wm5qXuT_B}f zX&;xc%B*J&#pwQetInp8Rcehyz9R`>>^@M;*2Q(pCN=5la?P>19OBNvzBz;!Vs} zKQAxhF}jQB4Z-9MkT(|u^?d4R%vLlc3f8OCo>Z&FGd(^vM2u2MDd1PJ1Ux7W_0q(* zB#f=#0S1HDNHa^XL|rn*b8R+xSYZz~7h6g56He(FhAE_#Rn$m8AY7g$-V3mjo`|J+ zHI})WKa`yS!LptW)@ZWrP<%SS2&>F-&``v-m6oE2G@Fp@8+^tjTKeh25qza+owG+q z%`NJKg;D2TavDdQ>ngDLnxS4;VT;QiNWO>sLBMv(KHo!K`Bs4gMW+OYz{{R+w zP*cJIBicdJ*~dXodydgbOoUWEk#v(0&iJifCj>k2>?>_7x_^|Ydp^avwZPQt$8T?f zAav7K_OfJAxap2SdR!A16U6lG1}h?YE)MnbNLKA~EKT@Za`;i2TWW|AM02UwEpA@w zMj<6NRoSW?0bOst&PUwV;nkrEXmrs_&5-sKZ!%X(Ycc%WT}UwRIq_AeitdKU)pT&Z z*T9>;pB@t4UJ*vt?1_`MhVMt+GE6V3_`U^SL|(57uaabvP)5@bWz)m=bsR^XUH-@s zvXbBVuT1~)weVjaRHt^9}^3yUXJL+y#tHPHB{SDD+ww-Q7Yi0oa zO~Jnv*}te0N#0^Gpwj}wqlAW}zVi7=AWnDGC z-NT-_#HB*KmB=)a>IP24Yg-e^e^cTqY&)XDRg zP4Q{)3~n4p=dh~y(|BkYZg^!!1zIz>tD^!BZe8{peV~PmBDZehnpU83t8Kx(LS#Qv zxeASOjJ@)CvXzpPH((1ghohUz2x@6J4}KCzVY{}f#^4hiUNrt(?@9^V^5a8GBGzKp zhXwQHRok0=Bjec{sQA?uF;KXMUBu)##$Lv$6LeJxJBHZ9!O(&jaBFXyrNja{C^Wpa zNn9E*Ju~SY9Ca1&$qS_}A%)k+D$)S5Fpj$q4PwNNJCCD@AHESMrk1m2b@fpj>IX}z z@T~ocBE!C(YCW`3C}1vy0b_BXAPsmUv%Qvu2i~_*NflxrgMJxTfK~d&l&D&`;>mKw z48Rs`t&Cp8`vD(U0llQCDTaunoz)}0RT*zu`C@z{F4ber6GWKaD%gB!CZMpx>zti_ zf%P5)Hz~<+W2@&vo#RLiBhTb&rL$f@m-*V#MN~Y5z_9nke6VCJWvZ+pRIb~V1KFn~ z#x6WFQS#aSq>6!wWGps=C)Y_lWMVNz3AEvNyR$mjC}V9csqM?NaC^$5jU*z2UW9ZO zuRmkBwkeCO)LBBBeHY`icQxE8;^CZR{P*cG{sWR{X6?xdD>WyQwIv)JIl zaz0nXC@{)Y!{{SVkioDzB{9oYX4qqc_mUMl$sxHU+U1V`t9e%|f$C^p8cn)EJ7}Tx z2PR{^K*Vz-*qu|<%|ll$H5^invB3ht9E%)DuGCO;9zD*df;&Z_l%xtJxCO-$cF|73 zG817~hBbpqtUg`8nbVR5wwvw)@;p2I)QO_v)KIUGGQ~YcM6IoZCS&na%YOp8j-ziJ1H@{hWeQy}!kT=s zM_W95M(Nb7V%n_Jc0N2M%*-gziz66Gr_5h2e8m%pfidrB$u=6?AKS#1u8^u-nWI%Q zbjJ#gpC?htyt}*$Q5a&P=gUM}d;uN#?7>o_J8A5k!bH*+sI{==j1GF*l4hxrrEtWj zYboC}!ZO-;D8JLgOs$y$D4#uY6ipnwgO-gw1th!tw2~l@wYA*IrOo_Ha5;Rx5eKG( z*+L-|)@#V~*Yy65YKWLsycl$qd$#WLTCN3RE^XZLHeGT9u}U+hC7GhdQI+bcC(cqZ z0(y06W-2UofuykmOYm3T%7paLAG*NOZw<>8RFzptnKwIB!bQ#RbtdNE@l%fi3{h&E zDIoBg8gRUsRX0{BYbruh#aRSY!+RA4W7lcFw){f3Kty%XniKm#O&%#aeT3oowgq1+ z`3VwLLS$tuq&*w3*2ct@9lksxdH(@`5r6 zW|b_Te$E`*;=)fsq)#hLgixW-ET1w?(o(uDRbCkJOmQ=zSgRpcPl?@ct6qBj&3JGW z-I{dH7@8U}u9#F}R8zx;Q>-p5s_`Fm`LVHLO|5k+#C`Z1X=7nZ1P(PbCgf}~mY*@= z7}g^m4T4}al-SNEiB3GnNETV(k~onyl1UwuAOpwY#Mds&X~t>h+tWlZ)ZSXE!Ld9C z7>0q;lNFLl>1me!eb|OVN4IFye0Xz`x(uY!9MBO5g<|O*P>UUt8Wc$4YG|UUsv8c& zD|w8AKy}i`w-jHlB9Pj*Ge)|jCc}v2?e7Z(oy|niBL4uAse~Agy{yAutA$8^$3`kd zrf6a4t_cny>3`G)Q>0HeO1Pw4Ffl}AuZo_ESqiJ^c1Z}m{5V&bFZ`vm&l+E1BHdtd zs~r3ua0$9$(+;!H;k64rMq!UT{KTj@Zm{g~21_O!M*y-E7yYdmq01GForc33?6|S#VrIB+65gk;r zMN27IX^p{-L}g9H4#2M7$LZk4&2kMFKAdR_mlHqXtD2}XwM_I_O>x5OF^F)}v`A7~ zqfTVosRQ0OzZ5(WV5<{UWI2wWG&*IP?yzONtDCFv+{oA^9w9`TcNC$o6wvf3CrqvkkWXtnoGOb(EJvDUB$~Lp>k9y6v=< zbe^A;F?FM&ZZw5+R*Nm6k+(RH+xkkqTS?V%*=?6*B*eK&3-^nMi8(*?Ft zc$yx4HFSauvC&Ky7^r~9RgTRDYnEAn9^{iSQDStwWD)TCc#|@|E4b4WJknEbqz4wPyz3YaMUm{jHaFMf!xRq+e5kWnB*j*Cb)cIT>MSuz{$!O^C5tz+ zf0uK?D+`9GmBz_)*0x*p&(rLySI~SmTv7{HRbo|HezmsQqkrY`$qcH%U93WYJTyFx zGh3Ahl@u_rXcRX5ajtcC-iQ)D5%_S}*?@tw>uaar(=d!l9wzkk7X^Y(vJ1fpw zg%i_7!=)KZ5v9vAQR4KeiQ+g+hK8;f-M7b0JaIC(c`Q!UKWE{`9=RI)>9kp>qBx4L z9<9SflDrkJS$8!U-oEr|Wpx(6dkbs9PF_jGP=4S>6piU7ON$oA(!XGpuhRN zZyI!bkAT$S`PQbd40)cKj}l5HrjTqVI$}~mYx|Zvk1Af-O@_A8`!saImaeB5q-r=O z5@Das=Zcy9&6bTDX)+xTzAePbxs8ucV?X|x;gJ#wHGM$IZBn{)0BRfE)EG}E$8 zQB#RwUnG>`OG=MLYSmx`6IQ$0Fyla0 zd!dpVj2zL>Dq{55lwx5bZh4_DtL56-Ts^@&Qp&_qN0Lgh6ghO)r&PF)Q^hy(-#&v1 zl3ZsHeHUs)K|6l;aJSv{aTV>>hR)&vr4SkDyG7FBxKjy9DYTEV+8Mvh7UuRS;qLfUzF^2_YCYfmSPG z5BBkO(`a>)79<*G&BdY6P+--abiXjCRI>YJOw~ai9hm5ha!rQs-z*agB2`nHo5Wav zLGU&{2a%=IZdp7d6dE2OZQeIK92D*{eqzeGj(oXQK(w_OZVicIkYaF!@@mnsOgygE z9qu<>PNK&BxOiPk(WnX|3s6xMPI~o*D&x3DD@dtHQBz4I4IGM~ICtI&@B`i9)>h|) zjucmzqm2zeg>D*^S&!806>Mo{G39BVq z2$m>@?GXvSpGnm5Q*8#(q+lr;-Yyw5-+)omVl{czrbtza;u64`YTIdGHy#!?;)jwz z1FERm#L+~|SX~V!Zu3fcBCaZmWR3JCwh(Riju|qoNfchr9?8lP)UM`-Zz%j zYq+2wfn#B>hXW-E4oFrsc9KdqP$!xCeT-%-w zKw7`tOC>|^B-kGTZ265@^#dJ`e`l!<%usybdg4iO3BMlE{p7vY4z1H#*#Lt5j+tc2oDRt4(_>(fL`r0P$nNN!ZrlnD3#x_>~`AR3*9yY z#2OT3PQxNL(SVD|%w0CXaT;_IHZKkl9n!>klGoCwk7Ij}tAw`6D7cC;z46-`2s1}b z){isw4-RSkq^phUy#1T3$q1&kzu>RI8!z|;1lG_>&NLHanRw;g$Cc>VM$yMskguBC zc7$7L@zTI>!KG?R@}k#HAob9#oNx)KF>IBIP}3G;Jv|Ka8@Ayzs0aM4JUE>X10s|- zh}l*&_ys;3xEss9whTrZr7+15bdEuVRX8@++26x~CoTyc281j$0Too8PRp=Y`iaYQ zaKNMI#MBZ9fB;4*nq7P?uACCuIzuGUMbksSo)os}rX2WABUeBpRi2JIr6jM}-Ca%Y zpQik?%aqMklpRq=KMl&^Xt1ghjIvg#o>sNDJErDQ?65vQ&JbL@La6%PuMb@yGLBKe zE3-yAn1wpjoUa6|)Uz>UC2L6BQ0Pb>WRa(bA9dw~2;)eZW?aXG5YJE(#hp6imoTa^ z<=_-zYKWnfc6iajxb|FW!@Q{IXp^+jZel`~2MQAXF=bkbG5)5m8x&qdanMCD^6prH zP@$LEZhJIy!kVRvSeT<7LxIUnkufHz!-aB3EV4+b0<$YSZ3OGCx8Xuv@rpGJ;nz#N zgVCyNXQ%x}lP<$G4hxp5a@IACPl!Wp{{S-$6ceEfp?3GSf!qu6746(Ql6Z)#+uJ0x zMIRr-ZzW>+e+}y#7{pGL*sf!wtILzrMzOTib5Q<{PzP&)YkW9Souv;H)AnmENa?Tt z)KY#T_{3);^e&J{Wtu$CH5Adp!~uM{ifw&+-9fnI6}#$`o|yU6-JUg}az5F@s9&md z_1LU9eit1?6yiF#E0(5Zw2?l-vV~*VFbi?;;L(Bsnjv^<0+`^%^Cm~e@vJJAs*-Aa zQVb@ZuA*4lQWYetF{*_3y901I>xe?qCY)vBnTlrWR&~wQ*$*1awRBR&O^j7h*WuN# z6tM{2l*puj!uDY%oKs-J0_0MAw^tM|`eDN}Or0FZb517%)wLEsONT*F7ke}d2TzIM zCffC1m|BL@N0%1KC`jQH0B4F!9|6N=!LXTWDCvU?CoWN=i#<(0%fe6v&;;BUZ^w%* z(xRz7GgWYnF+@`{;TT01`N3+8L`3*zD_ctyD7hQFsICW&t`C221nju43~ZqLnq<{r z;q=E9>fRg#LKLO0hAI4`fA?=Nn>T*?a8T%mPn8m&0_=2F%U+t=qPh&jl_Q&W5rR*M zR>etSxJ+V&caMlb2hqsqG;2&Anib`)5=v>Grg<+G%T@W06|bv$oKB_j96f6$O@=Bu zYO>MD0RRo<%W0;(v)4M*6T+8U+IMIqoN249qNfhZlyz-aO8x zkPQj*D`m}jW^6`|I2m_*%@PP(b-No#Py7!O z+yWqx#+J502OX79exhhyGc4F_6Blr_HS~@^3dvPT=G*FUM!wDuvYZjsKzqaivas}L z6A&~QeLMdEq<=AmYNWAk%CNcHe{P-lqVP$YvjVMaFLdh;o{(cQ)5}*o;dorWYOz}sPSzi80% z{pl(bRaLwLO*kbrMm3J+wWDX4&|%ZXRH;q~Dq)BOa-i6f1-^@N??OaU2En4CoifWM zCL>WxPZc#W!`-HZ2GV4wS7*P)2(xhF-O^yvCz}LO&!fZZaNN0rsMF~|6d&dZBCDp$wIZNTC-Z75wX8`M(@OZ8a_UZR3J#v-05U7K~Jrin`{ zldgpKJfdCwnT#n?k>kdVm#2INnCF3*F;$FZ+VAGsbIh$}0&1V?{cyF3(`jWt9}e6n z%v7S^T`FWss0XUcw6%E3LGp_&E5lNdt6Z5R{Vb^Zc!EW^WYgXZHqs{<1kqK_S$7D+ zFpOst#G>6^F?tunCyi{050+k8Bx_iEvF#S|JUU^?1PU%%G_IO*mTJd(VVLN8nO?0# z^lJ6A2BPZE3#!TGxYqlE+QfK{GjV7x5KwUx^KX_{tBqM7OZvBwy-8&JMQR~zFF4?E zHYFu3GwztisuWF3&Ol}?!3a8QwY(1lE@jSIxur%y*+(k9OX&(5c+n2^D^Oz1uYu!u zG?-O-2=d9ItRQTyffsyCZ?z<|1F)YR2?v54v}i<{CcL;RG$MW+)fBi6W%U;&Tfh1( zK3|e(S9DIm#fcRgPjbYIeH=r*O@|vnt>mgGbb-c%UtGDNX6dd+z>XpQnH zGpbF7;#*%%zy`7UM+1AAYNGQ00LA%=5ofLfg!$2Q%Gowde;UUzYU*j}vd$@n;gmRe zq9z8asEw*#XyYdK2qYWi8ZPS(dq6aK^rby?8Ma|XRJQ7`P_RCfW$AGYMnhMQ)AW<(ZP<6iN?gI9j~__5)2vKMx}DHwFogQ-Qbb*mL{6hd-tIa{6c7GunK?jmX` z>q;ddhye^yD%eDUzQV6@Z=~zNqF74}r77V-#a%7cl`D-Hewo2TMOlc)j8scINlzr0 zaV(~qJ2-Z_3ldvxyZD2|H$ah3wxSI#G6i{pn>k6p^i3;C3&z*?#S}n-K00wd(8PID z?71Y-Ue1`EC1z%Y<)vv`%O*67Rfn#;fO@| zoYeS{se(yT7|hSLhQXoK`0+MxffV*!7G!a&Eb4v{jN!PAe7I#qbh&b$FX3~+httHs zkD8?=BXlf4B&lXTC&OL?t(`#-Ml(W1q>2nM+*Rel8lFW>n5`K^bWvqyk-hgLQS2XA z7I#1{sFf0$18e-WtDPluwAcA(u>b(OSlns$hYZn0>sB;T;FgtgjH>6#c=0?+pJ;El zd{U!U2kGI|VkoFdpraVW;}x|v0sjC=GclSnZL|YmQ~~hfgs8Zn}k7EFf_royY? zVq|$L1nfX4Khq@#x4?c}O_%|;pRjNsP+#g3El)$3GOizoQ+cnQYEqcfsJx#o6-vb+ zAbo#ORc$)o0;5gB) zOh&`Pirm7ZHuYB!|wMfs;$oEwmgRZqRBxFb&vA6bCixD*}C%9i;%WYNv&<{>5< zT_;Z}NRkRyn!cJj{pB?AqbhgO-L&9yIYjun=tsNP5WN&(G6o_rOuL!#T=D~1gkuzV zt`(>|D5`O4dWft?f-@2Dw+WPjrx3mzee`W`q@}f_(xOCixRRiu^W$uqg(Ll2@rg! zxzj30>!YbthrMh$TAlD>f|9a2`DRsXpO$oR4ej4f+$2WYG}Rj@*;Zna*S=e(jr@y> zxYC;5_5T2sPBgZJ8;kIr_5xB#=%YJ#^(<9&XDk3zdYiy2Scig!1~NF%tiLL$sMp(m z8`?YmPf1-)r@-JTS%=Y3)Mxnc+Ef0Wj4VOojCA06KB)xia-zh-Ev z@Q(6~Z>4mSm#N)M!fBO-W+Md(QKdR>8_Lx)3wtas4-@93_erbe!}f-ZWgPP0c*bGM z6;t_G%ZIFJT&$Gs3Zo6%lH%L90s!yAaX2VZx|fVm#p&iRif8_d_2UL?BA)`OTu%$i z#YD4H`Ns{*m`{^dh9IHY-p)|_q#hII03qa=nWYwzP(k5BpQ8Fa!GK_WL!-rOTB53- z9)W}nD1VX>P)8F}Aict*vAGxTy5qkqcA#PeRRN0s)zA2hMrrV#k3}S4ftkeRY!SW8iP!kUl_|bz`gMDt68t3b#!E088X+UawHNw1XeOa{U~q&3Ry+Kn;!BP`0@2 z00#UXShN5pg73HjfTJDL%-NH2cU7~NGnwfGt0f&3HUhK2CQ4~t=54`Ez&5_W9w)kG z#j*lTEwp{KIA)l-*Vb&cn6k!W!oE@p%B)5@Nbp=ul%r714D$JmikcR5eY)}dw$W%H z&z&N^xk|)E7~e+N{$9boCg(aTth-s7D_b`pX)yR1p@mKhOcY4RwT;*g=I4cZ(@Hl< zgBX0x8fB^fBcs{r*0*BslJaz!6bvir3z1xuN#@v3Ub7u2lSU_C_akMVLc-(t9Ntajz zt5MoTKXGjM-GpjM_zoN)q>dDr-D4)2 zbB#7FHYe07ZP59+hAUlDBcQy6%n>k={eWAKwGf`FNZQsdtiU~Q)amkxf$c40(qCSLWefHEdLnGG@gR-TO(Oh&e@2(b?^qp_MepjEi` zFa!Je4!CS80ig?O)3a?T7pS<^Z6#$TO)Q4KrX|3sBycu}(m^RNVXeOYCj6=rsT8Tp z#}=5Rr>LwYYw{OQF>Dr!nvSy&t*629Nh<2rDw>*StEw#F2_E1m7X5|z)vJpuAlB5- zQbL6gnm?bya})f9YT(uQL@9?;lPY${vYaN8_oo;%Q$1AWT8z1k zbmtYRoK%e8l_)W_k}GWtDrbq7-qCP4ca$ztuRoO)-5{k@jp+x=(cw=%#Ew+QsUBBj zc2s&%artrU&}3Ha)&L%La(z6@7_K3d^6n{z)EBIa1)+|n2}uc28p5hc9tBm-yarx6 z0*vgTJ)rOk2x_UM8819XC3uQ=r>~AWSlF;Cw9>{j@HS0;o;yAvPCgAbWwoKeaVofQ zEJk_^R8myaR8l<8Gge5JV)7g40luF{9&i$IqOlP{)^ti*?1PwvMJf|d4Nu5Si+Lle zFuO~yimmU1qt}{oC!obJgrvhGbgT0T znpP3GP@=(aZF`OvH!)AGa6qIsbgPkZJUA6+}V}rDpX$!IJH@`9ow62wQqypg+M|L87KmwLN-jzsY8ub;8jFY%Ug*obmw)K zeCs7VaxnHC+kU<$b%Lborvs2+ZKuwjq;;|3xo;Gxj+Zp5)KfuOh!SLwK`54VPzV=g zx}iQN;mh2%Qgs1^X`!e`8ZTXBf|6{xj$u^s#wex6X|UMqB0HIWQj)Z~CD)bNu4lUZQx}S|I?pQ-XsQK7GEBA#-av}mS52e0Tz6 zo{Y0@4UziMH8yabrm75YFX9+w8ewa>7N%PI8+pW9(UexX9yZ}_@Ulw)r>2+XDh14X zD$)9<(9EIL46}%1*j`wtuEa5qmuyCwl6DPJkV49@3bn*FD?zL5-I?p9(D-ji0e4tAMsJ6GWYHF|)iQ!2b zXoW<@E;_l>j6s@pbIV;SNq?Aw?mYRr0isak2;Kw^#rf-)jRT>xA591~fxmVioj zQAOM9aFrwSD&0g+4?GDQoXn(?a2Y#%Vt!--Vjw3F3T ztnyOJ94RuBau~|M8~X;lO`10(PBi9N=}yj?w(hJ~;W6NuKN!I`K^`lYXeVk=?Jx|2 zXcQMZGL4O5cmlU&L23kXp<3RQ3MrKMm2MHTmT7`VEfZ5AjgOAEs+lS9+9_i`WRi&zD1i(<)y=(@98!#FE0_u_*jz^x!*N1s)jX>FN#|wzEXNU; z``>>KSA-fWi8Pwb)QF-rSvJm=W_BS#xauz0<;l`@Hl)CA+P#-1b46TRZ)X3HN zfUmBtsWxJ;!&f^105%26olh+LVM;YyNk|xs=zn7W;kF&0IrS{y2&*?`G6;2{&TIQ zlWC%l@{SHV4zS1A7uz3!m3q8m}~KROuL(@E|q^ZO_Z@^gK+ag zPX%mFZasy8A4dwU;44X^%-j2(p+_@1VULC3G1u2?Q;f>h)$;+W?10%m@%QqGIK>b; zh)6v&TC-fKOPnwYkr>?-eKcS_VpKX^WecGM9e~_^ILTx{r57S4f4;8edB| zW*u3ade;Q>B5K(q!0}8vq;3wAQ;PN*8Ei%DLAP)?k2q0E5^3zZH5wkVuAbrYW=tOLowawk%7jGfXtyvsEc z(aDG7_%&Q|Qbk^v4i^Md)PZvF#usxZW81e7uH7y;oob9J*4)qx3RQj{3yIA?STQWi zh%PZxjb=J&Yf*>|4M@V3ra*$>5Xf$;eFqfgkP?t7BSl1+um9G0{6ldpGZV`FCdH$Z z=6sCAX__WRUo4CkzfxEZ-ract?%KP@RCq_urySj)gaCHW%C)TPnUX%VV6{>&mbB18 zhzL-U7$nlY>`s^32PBIWj_8iM4Bd!WJZN{yxrZx^`I@nOa18LEM0#0CeJa(5~zRn5(i<95aZderB)0@k5KY8-J-T@zYgG)VKu49f8H2i>+FT99(Kn#=p0YDO%bQ zPBwrROwqsVPfD{c8I9KWYm;F6yeDVd$$*XGJ z><4}bFB}R^nkZ!usp+fg={^~Sio8UFsD=E}qbqzIs zBT+Rs%rvdGDc2OLhul(Zsz^8Ddt0S zwm_0hUN@EG{U8G3$=}3sjNdKCXN5d%5SF${nyxQcxqg-r(acm-Gko>|^2mpGmKMTg zATiSB{264=h)|%->sZYc-kQTZ)M4mch`*Vv5-scvsmOn?wYY0?kZ8T4bpcmh(>&*o zVYCwAH3A07p+?GQ|unh-U3pag8LS&(I_oC_TC z=}4=Vp0Y?LPW#@9V!(myHylh`B9t!hC{aM_n8&h*Q*!-P4NRh3LMZVYM#{uTBC4{G zg2ZcZ55tDGnikoev{tQ2R9AI4^!Ub4&CtsVl%ZPf(yEZgR-lmu2*fi7?a#sjv2*y~Sb2$t_U~GIlaYd?v+s2uBB`T0&i`Hkx@tkijRM1k(65&+X z%y`ZrQdAk*SEH67K>!_0q?7UbIB3gZDxNV&-*A-d<3L^}m65I~Agz^<{)RY;>~iV| z-SlWUYa)@6G?>fP^;i~erN!ZzN;i6Hm|~ihOpNX4Q_E%m9_2qSF>sA(juhpw2vpJT z=s&DEGKP4QCT55#D)Q!df^kn&<=#3xViZ-Us04sjBwf+TacxEW9tQ97#dk$%7>YKv zzm=sb<3eg;cpgp1sxvKZ3M6@(5Ndpfj#drTbvT`ANZiD-A+;<^WM(5`=swXLC$W9! za2qJv@eHCmO$%K+>E=Iy=S*W4%{aAQXRgHX&+7#?2{J^qIBbzsOB`()#M`2YBH3hd zx!CD_SUYoafZQjCM;c1o5^<`{>pJH1)jZucVXu5=9;_6aR5k#3gt@;AV8JxP;2I2a zR>}-lI7G5ATDq90e=N1vVUz)N_zoMW$P`?VB+!Rhip3Fal|_8f<*Ldz0Oz=Gub%Fc zRVv2=UVLChfo5uhBeh4))5d0!`%jrcPO2<^An`TAKv1Q2>e^^N$PE7g)fRf0kDF5@ z^|K)$5Kj2dj-#G=QoJ@++Yl*N(<$=oboGZcO7w8kS5Gx8it+$g&0WP~Rtnnp(2>nv zB*2b})w1^Rs~^MjS4>kZJ+lB3R&lrfLZj-;sCWD0F-TS3Lv?ab464njfcq;_b= zV8imWUq$}_i3{=Oo0U>qg^0q7228~3Dk(8@K`D@m%IOR??u}h3 z7ajah51dZQDb#D(lCQ|5ifI@$v+oilEG)X-#2cIG%Aqvd&X6&vc@qqluP)P8tOiLL zYN_C5?!W0Xiy!$2^7j}TdeLO;p+lnaCNrO^9$3~&TsD?GB_m7NG?(6e;t4;c7vdN2 zP86|Zg&CsD(|=Eux!XBroEg-*VD+s|6-KD_;8ZCV7P5$#UyJWE9S9M&kXYLHii1r( zH_K2`WBo<6zFmGFRB2!%zm|{~-q-&CiSg$iDnfe2QB4hJs*TP=!J$lNKVp&7m5zMH zB%34yafjsAP)Ihl_aD1~ywTDiP_HFsaHfiUKMug~9BPdt8)>Q|u0;1p3}cPK0`|BA zP9tSxtRAW~zd%bQaG{T^+0r^Z6Ag`k6`oj<8a=@55{4sjzkvJry49UZnhHMoD8`E> zVa6b?%vdzub4ZO_OLtEf^UzygyN4|Z1PU!uv8w>1#-oZXG8#$bhQ7DRh6rL~84Sy| z#>GYKH9QZg6mQh%tsRE};S~3sbFrnub9A+niE1n4o~}8b<;<-e z()RGu=ZrOJ;s9)?jpo_~JuBxN8kuuESjBvh#SRsX!dX>>Vl&YGqQAn5VS9H^}2&$mwz!Zqc}kp_;xIwFvrH|yYE-F$4aQT{Hn}OoSg^xhl_JvPZWof*a>#^0XsZ~Nt zOfbk{O{GZ|Yd2%3ZWeD6)Y6bRMJ&o$4uu}N|JQN+Kzoh{v_uq^^5|(6eZ;s7%=gm%=(xYLUP*RS z-Fcb^T>Ze4LYGM^Fv|QltXPF-kZLgcEG8OOkhq(2Nm`&r7uu_Hem8d7!jaKVFrc8L z6cSZcoL($efocpASVt7b_fw%iNfzSZAcILmq{uaAo|SR@3a6!+{{Rfk(yZSlj!?}; zDlcc1aL6gt9|B6Z(rxhIUpQ@D@=8Y!#)KJahJpy~(+gZjH1WkiMGSO>a*dm-Ax+kPmsxYMCD zU2$)Mj@qiOmEmHS52>C>HN7KA+qI$KF zafz`x{KXdx1tY_+(YJ=g0;*)BMDU|QCL;6Yx@wA<3dYf^4>^e}2B4E`6Yb&`j4CNp zAOuiFk75u@g{2%Zns}+&o<-fEd(K=Dw*LS{_^VD7oXo{omL@82_~~ept~qI>jKw=Q zzUyIq2_62P5`%>}p%jD8Q~aDX@y${Gj?>}O)5748&M`WE`gZ2P!mN+HP)8Md!A9Mre>K#DkdVM;k^sZ6}?K!S$7mlthXL56=o@i zS7FFph~q$aF;CpM*8PtWJ((paBx6dOv(%_KQs)ZjZZV5>QcP<H&CCYiK%N|MW(1>V!-?6CpQeFYr(as0EpOlQ5D04m^*rCyj2<)=AktYwd1U` z^AMqIs_FqOO@Z(A@a>^URGJ8&R;A6EmX8l|VXBfD46$8-xRB~d(^GyLwo{}NMQ#rf z0)!;PV??B;sU{ifL(H>oQV^&IdHTMtG#rsmw80!JCO1g**;gNyV3S8RbvKymEX9)# zjluX1Cv`(rJ#I)z!h%etRSRYMYJ`|=XiJjBd!UwXU1J)m6m)}6*gh>^g5{iAzAAOA zSSn^ghsZ8%QL#^dX*U+*j{pc2cJV~A2J7YFs9GtG!24K)746AVvQRUQtiAX&n%I#PTN4YhJ^C^ zh$bmIktr0E%+m<4h^T3f_+eI(8D(wlwIe5W`y1cc#dhb#CX=jqaiYCLivIvF!@how zr77y;mbRWq(?)e_sUL2Z)NbLbfd-3}vYM;vT2`boZriZbpnI@mAPsVF-;X7@rk_b7 zhW?ECM=N1b&rGhKbz}L2>ci&c0R8+$nJj~aFUuMxJn2Qz*MkkjG5kRz0jX=MA~FI# z+te+NmLI!rCU+EoDOJE4j8Ng}wX(JilxEKuk%}j&#nCY(n!|Y#igZ>XPNi6Y1^e+8 z_)%O_nP!j)G*k1QS-`Md&7Nv9&1*GAXRgFCTsQ ztD`X8zhapl*C#@j9Nmjz0pUt>7fzK9s)g!_aoispqBw|^XQ@RXNR1Ilwy+mc1XR4qL%M75Ok@zWs#&2S{J zJFG2XeLfs#TnQDR2{F@2?x0d)7zI59SdJYG7G%__lAuUd=H0pG3QogH-)&%0m!Yz> zJx{^ql))O}G1Sl!BTxd(PU7d`axcx^pV-%|Q{%+c?x)}_T^==p$6pg5k>L4|w!YA9 zW2yS@#x387CY@Ehss$G>PFZ4HR~FA1dL8CJr8fX^A3C*@I`tDn zXQZl}9*aHa$|?xaD5cDmRFG4{8pIpOq>QNnO8_;n9?*Ce-j$FW)zLysg{&3_17H8p z=lFnBnykIjyhWh8(__hn$1)M_BjHt#bAN8Z%y`{Y%j%7h^A(UA!hdF;Kar{l>fQxJ zI+o+IaN$fx}l#)&!a{B=b;Vv(m*P zvAYV2sEvvn3+@A6ZvDw9BCVIRA!CgL^pZ~a-9$1F$kiJRZK|)9#1%I0#cD8`F9uv9 zjYsvOPM-ARABvgdto~swE;5fxxHNSiB#424@j}}0xlLxc>)bTRguvdoKdwHZb8+t0`MM$BWtGVYNgVArMy1Y84%Bspa zhYrW+=Tckrm~III$Dy`?fW5TgWuqY8I0)K4VwPMihLJ-)Wa>m1t^x=Gi~#3<7j zgLxM78xQ%w4ZVTEw-L8(3W_xEglan}TZUuPbvve+_Z|LYQAq|nhtwQ3sH5|vEgl6+ z0-+#i+kqnfA5R)mJGT%Il~lS5Wc5`}bQ)TmQaIMSCXws$%1C3{8{B26+h!)>MdN;->& zQMyNm^wJu<0)h#nM^P}Ws)umh?<@Pp#2q_v9hH#$z&$jhF}Xd_>Z-!Q^L(=AY^evE z9Z#O}RMITNaSVm#p2c`L9hYzUpvi4)1Twa<+TgV`$ zs&$DP{s+I)#o2NJc%F()bAkt56TX;YpD~VMHI(0wpQQNQuw+al52mG-nxUwNUPUP6&H4`&H5`GtKA zHJpOdk&n?wR@E6qlIp$O1!k=&gniA#4X_Fw}c$HOq#>WnU9V!_Y+=~y5gB`k- zw4ZPssZ6^ONL&NE28lKii6{A?nd#XIVYOI_*@z{hW^}jHW5eVm_mon%KWB!)Lgo!s zhE!#mT3XtP_f*44n?!RmIC&QFdJVu@ihWhChoolFa{u@zCi20l5jx$L( zMPTh12HTaiU39k}LS)i%A$0G}r2yrGBZ9Mgzk_>$F9(8naHPb4bp=WM+#VVN*JBAtxcpE6cOdjdMM?h z>INx>Bh%8-R%I+34XGcdu35x_K&#-3BBL~y($*UBYlso1X)+f$iUN9>)Z7m%M#+uK z9ac9{O(S4gYKZx2kU{oB08Yq}ynB=FB%W2fRlIyZZ7uxD8Ady4tMKi@f6kvnD? z0&$#Q2BgFB90L%n-pfMrPdzwT;~E9qbzf)G!z}Oytj+HAKJD#F?--r51 z{#DehLoGIT!Fq*@Q{{ZlX=(yv6tTV^Q&kL*Jl9r*T9EFHk?%I(Nz;LBosZ6HY!C`W z`{?fRz`{WyW{`QC1i-yX(^uno1UP;VH7nEB;@BKTC#ja2NF$5=F=>I4H;ov|g%-#~ z@7!?B4ldZjy|k5WCFII#usY?_<>}@LS5;3+(_yu>qFP$~QYMaA!phNYc+c4&t;O^r z%rxMqExPXrnj*MCK*oz61n@_haf3BTqDi8sk{RX)%ie}vO}pIbe~%Abz)^Y>3W%vy zm3WN!r7)(&1nfzHjlI-BEKa?F9B;0@DhF;9uBfc1#Io)yK|NZ?n0<6mRZJ`y!NY+h zf54?ZBSDphT7 znq{`*<864k!zPQ_m@`PKiD8Eio|z!?_d8J1%)mOO$R@<=pyGt6(+?6hP?gd;@kNv( zk>mu@O;lfheXCI`Xg!+o9qK_<80AhY*-C7jDroSjXNFQLF}m3+YT;lDDzwkAY2rn% z#vl{rPC79&wwK*4f;@Al*gjH{Q4&?nK48Qu11{=kfX>mIU$V$oQ^dE!_LENK>e85? zE{$um7JHWzti;n3d_q{Tnp&z=0ZaKPBq|e233q5aTZ`F7l!&IToD0T=UY6HGg;Z3~ zSJeYmjnS?u@wLH6hsho9>~eTXn;@u2qr8d8BvK=(@w?_)nyfu9TX(>ZmSW^Sl$69Wr9OrK^*jOQ`JX()ag$pGO;WU?ZtrlxM5^~ ziPC5);)>%{02#^}S_OgTQqeQP|8RiIxUAC z%o)_)nonl=3)E;N#4|)$r#ihIYPXw$M$=Xzd#LhA4MM~={_nkO_u|&A^f!etw}RAY z(fWT_F>21M80vmbo?N?4ZO2m4;zGcK;CGvzAj}2{^QTw}lN}T%RL37<(;aEcn;b2hOMc=5Z!8)eCj2 z7J{2T;Ssx-r!okq-(n?=;Xd-O_;lCf$vVjgK{N@vGIrAAp&6eg;CZh&E@_ffp`Q(+ zrKI^;RwB=M69v#*Uf z@ufdV>Lr7s-C@HfrYLGMbUD_aefOCtv5HvFm+&#vvEn<%&*lLeCOy<-*a~3D*+Q-- z44Ko=Mh%!|k)n^Mn4(a`Sf6~)9>xbZGBDpKH% z^RM$3rZiQG#41NkPSi3jyhAU#ZS3LOd2)5?qzk;#n5$j%`aqf694rqzb2Q zn~uPKyKpOT#*_gY1qfPyQ_E1;XlUqGaHR}$D^^Dj&PbGutO3+0CBD0N;U;L`h5(~m zCCY)K3F_Z4;PrVUskFFdN6BLt<~3bKT-1evG3L@S26FMVA+#pq_yvV$Qy99}G`_^+-W)jrnT}eNUQAa`ZJc4s@d#IIl?YCTQ*k@1&mx9dr1R{4Zbw#bU?1@dbLN1<(zW^jK^0~iA@9os;rYF zX&qc`Aw~9In>MEdR&CHsQ5DX(on}wY8KR38`KqIhQF%F9s|h5_yXFHR9f%u;yhn!& z8E7rJ=-X9&(3uoC^ou{^wUr$_wH&ymRtb!z8#1d}My8m6_mf*~+)e%*EWBYU1nino zZuybtR$tVfv}H`MQC8)imS1PtSROG-bNHwVLa4ZY6_K3d)RA0Us+@Q94w_%NZ(c zV_|b*2qWp>`4(s?Awp;+-l;1PX#W7^E~ruZn98!@Ii@T!uc(!Dj}B?c^(7GEG;m16 z<{&>wudSUC%zZA*D~;16wf#TF0?}Yt zp}pyw8#R+iqw!w2zwo@2-oW2 zW&1LrOKlwR5!Xi756+dC*G_QiFXVAk(`EcpI56**Tg@d^eJi`Xr^T3|3wv8n4hP=0 z(BzIHjnMx9?BLKFpK;l+x||MZ#ifNLqlmE^3Z&8kYY;JX62K0 zB$26_7noHn)(hsKvjOnaiVI{@8s?EnF{p0(y7+r5B2wC&r9!Z4)e<1lDh>Fdib3r|5DUSxCCRYs@xM%mc7qckLRS1(CV zL5t(n@W`~&$%|mvZ8NUblto)m&iZ(Jiav$nTeM2zsc!L#OyJ!+qRE)XL&DKsjyWo7 zr*SpfQFx@7wf>R_`gp5ep*2!K5GVuA8JbEg&6g|a(Wzpph14`A!9!ESB9E_bywl8u z2%}uF(iMd>;W^?=dof|(F&LA`ro}MnE=_=3Hm0Yy!%ikewv^J_>ysGqqu138Qog?) z64leGlAfI5^a7azrIeHLzJ&3s6oE8Za&;OhokEF};T2GTL^4w_1OQIiqdMQihYTle z6}$vdk*3En8f-3D@S4del2~@sM{%`+d-mG?)7Xw9&w+^dSo1gSTfMOEdx77yh~uvo8w@Aq;0<_rue zC9|_M8sqt!02$VFiUA#3I>|hdF;c;X#3tWQA7zykgTkA2;iyr==tY0cRp%@(51=y| zoG4UQ%?7>>EON33a>zcG+}D8Bo2xgaR-K~c!f=Hqk^SSOYX2NSp~|Qc!Bxx zv?wcOX+c7PY+gue@vQM#6)R1G&{1J8j7bz`aZkP~s4T!(-0UX)&S}Ajt+zPE8{fm; zZzC<|flXZ&B}X=7jHJ|TN)Yr2ibd>f0Jy)mfW7nn4=$T-eA(`77nDr@M~21>Y`LOWuTHnQ}=pjYey*d4H4&IV4t< zf-lc+Ko_;{J?{&Ad2GQ70E$3$zto*PX}coK5d^+eX7^spkb(vnj}%x5-QC`YQrGut|@}UjU^pj1X0t|(JYEQ#g>W~m5PgN zsnq*8819L15-8v=!4pLjr}<`R>jhNI4K({|Vlgn$qL#z8_4aV(*Kmq2?!<_zKk42p zSA+Dfry0Yhp_dh;smxU~?JKz_h9#B&`|Y=JW3_tIBLYD+ zHZzQ374f)N3wEoUPkZ7tzqZ_R(IFUhRW6oRWaCAbtT|Sr2FuhGv9rfbB2-q=JF9IB zEhsB}biRXz){aWzkX$w40+imVG0Zl*racR&rky4+WlSmRT08sF)x^`eZ-^{M)yA@r zqWgf;m#H1fNTM5rViSs*aUA;(n4hEv<6+yz=Ymp!G)xuIM_UQU@spIP)@jq_DR62b zK^%5gMMyy{?*8$02L0{A7g-wc>7xeTI%j~Uyp@fp#ql+17Ga4;4DODOY+AsbKC{Q( zX8~Ies2@6e>)D!TKkIES33uO!e&i1P`R4Xm4!4y%) zV{it%MDs)_)!A@q6+b&y(c;-+x_A+M#g3sRh%L29%NAkYWtMn8lkAfsZ;ta8;;*uu-M-$I~o-IMn5Sq30xQCnM!q zXR4uxW2~8iw8qdh6wF8~5c5fvQJ}Wf_pf9*i|I;AM$=2InNpRijYnI0*MxNE2Wpz= z;jPRwL}I{l>{eJQsp1+9srDjE_U^||Y2bN=ORB?V9v4!bv`Fy2t>SZx$Bg1K&zPSZ zg05pzO}V9ybrj1R006XU>>2^X#_Xa7$}f85TWY?ubor+}=16gcqL&Y*oogyE=cu;Q z)Y2R67be$WHSyq?hS1w_L?z`au8Z(L$8ieYqWXfGa`J-~Rf=f~i-u;!1%mqt@5uiE zv`||N$4}!&`>P8MgU-sZ-^DKumGW;&F%^ewLl%~fX@<9zXeyXq{{TVZcI%`3q?7$0 zn5FrHfUpueepRl1Nw25GdYOo}W3DSfhf&J&2}hU|EA3E$?R|WH9Fv|#mV|AfOKy_k zos9IJ>@Ho*%SHi9kSeVvbw6fVgQGo?agRav@HSFJc2 zy$?@aOX$C;yrG=(PI8hFpCzS=Oh+fw7}g5-44z4>qjRFmx;xnYi}>J*LNyj=GBj~6Ymss|cQ95fzQ zViw1woy%IPN7-hzqb+f#vra5ZL{eQu5@>$u1Qit+X`VTb-Y@85;PWPJz$cROESQ=)Jj1d_C?~?^{{X{D zmmQNCGP7;5tgKLlTz##5oyZ(dc8w=jO)$#I01A2PPfn<3#B#1jk4#4DaRBlp)on%5o-3F*kRPvl2JzXE~+WlbDh5pIAG}GOLEsd zW{`E$Q{>FsMKxLSaQsFZ`nV)g95YLW)l#o-2L(vx*hyMQ6sG-pPCF{Vs1=K{3t^8Fw1pdt191UwTRQd z7Bay}1BE4h;Rc5MD-w>U4lqLDrk`>kCwkaqY5C-31k+ggw)%GuDBdQjCSc*CNhneiDBV5bcQD!BLL z3e2j)-XIb8aS*mMg(&aA7|;=tbL|}1_f+GavN~95Y4D>IRW7I{jwtZ~V|x$Y98-60 zttcXyw{QZgKA(n;4E0!dRPjoh$m=K@GtkXQX&D(}65)#&LJ$iO6zRZD`!ZBf1wB1v zbl*D!6w*AwN%tC4?vvtfcwp)#CXh6!27?sA@jPb~#Hn!sYDJPq`Icftg__})=mz)p z@lLSNoX-b9>MJpERoHZHI=bA?;S-Lc=n(AYi$acB6Yk_XuJr{7Ex-T}T zRXSs}b@dTu3fZvtf?5=zqLpJC@8tPZ?B43zUgPQFVWa_9SU8$mWh_=4CK?5*rt-`X zJ!ZxN>;$Y-f#Jle$7Lu<2@y+tj@h%RxL#<%a&+Ob2gC*yE*~tS7<}58cPn1aa#2mk zj~TytyLc+-r>t$9xk9vXsM#yfKdbDcnJ~IMIn{@gaM~XZ zC4YPDTuC2~;Z|>Uu9CUo>G;u)#yu{2hL(d5YPj%0Q3Uc=%P_8;qulkcP(_73_47M{ z!uGS9VoZGLVzTGbApEGB`lZj+6<4T;T(#Zv_qBY@OZ$t5dMpr&<`%t(PG zA7Q_K2y&*wlCYum;0^5OFL+F zYNU#PQ)vc*{1SqaqY#cGSR-?_P@x1n`QuL?4R~tm_8LN(Fm!n1QstaJon=`H(Nn_Z zTGqS+LwjH7;u74Rx_42Cu31Aot`nIsc~Zs-w}OtiU47(9gK6Hwn_E(vX%9lGPgC() zoXgXWotR~kt}MTS;rL-$9I%2z2x1g?4Szl+wN95+OV+(e6zS>Wnp{5s%$1M2)e2~x zMz$tB3BPZnmA?eIk;1oXASmsjM=Z--7F58bSpz*q4I@O!xLa*H0ry*tx%V1rnTmF* ztFFZ`>{^~$xfHAt$s}U+tUic@kFQ9%z*Xz{EbO8Q!?9zv8fkxS>vU>52?Cieo(uhqp@ zt|W;YX+5K4C`}(Ovt(>T4XCWD`C}Zj%|Dhl?YI(#vivpez}>5*R3o`Yk_|Lve7j$S zW&A4`#3nRUiBpG4YGec=gNf6|$6MQIe%x;1aHyvnM}h?zdA&R2?CFKlS7&-}n99pj zEmjqWVX`!Jc%-q;r(|-*K}dbuNg(!>U3Cas%oLH~+f_DUY8ti*!PZW((e$p92&JOK z>8kOmLSR@10ZwCrhYP0=xQ5Xti4jbIMyVtA!qpG_BWC%5bWH>NQqq%@q|n zmlwvH6061Jn-Z%sJ6~%kK%gsFDvh9N!D9`j34k_H2Y6SB<3ksw>L znzJv&-lqzv>3>bB+3!^rWO<~A#3JEUiss)~*W<$7-%PqkRC~oNx>P23R;zTlahn~+ z5IJX(o}hx{FhA*wv}i|Q+>^+JgFw<{MmlH-#<1*GixsXz8#Fb_5<;L8xHa_lXn45< z5lkpRshLAKX559Du*}VYPc|Qzu$`4yb!{KJ<+M^0ds@Xx=*mTpW1-_$7R|biD#RLc z+U00iP}(Z;x&`VpBYLsPn7&BPcytFdVf5wm23nNrRqg(nL|flw3_&V2jOcyR4X>UXpcBG2sbMfMN7FjWuJW z)OE15yI458saX+NcDN)Bcvy2bg0ZE_v2rLn#l1H58w{t!CdTS1A*59K$)^Ho6$Elw z)Ol#e;F5cG;^uR0BP$`K+Q-^Obvecr;syBr@ zmc%e4xZ(2)?-8mZil0G3^qNd!6sBBRf=D$H!3vw%ZEp4)Qk|5WQ8X=diyM}XlBSTo z+8Wx3&;e_aCGLH__?GRt6>C6b4m2ob?Bj~dobVbbDh}wY-ePQ}lp`~P`EdwsI%bwS zV8t2EnP<6cvduObm!W(zvFa;v9L0@F%OurRG2(SCxUgpKPNPqwmAXfcn_z(_jVbWX zrY;|VR$(GK`70~_W*VuPT2Fd%%p5m>9#|xH<4U#wgI7y{<5lgGuuNKfP3r0>znfvw zQEkP?nitGjD2!2v%8{-1n|Rxb?!<@`=3RB6&lLdON|Q0g1`k1)aPvi1fz#Df$2yC} zH9wHzA%5GE*W>nV0f^&TySpnMRA#W=rs6oJ8&yoT1V>3YYKbl`%1^pI<9id|ly#JY zN!oi@gGj8$Rb7ZuVs*4N2}@A$JXHh>Uvzh2+p`UO_t%dyLB^YO7^T)#&Qz52(??rc zYkYu-9amA=&X|@uffuN77i(OkmC0V3KC8fAE~6z+WtN;jmhNHja}q;j+At zd+>(-Tet=9s9iV+-iC_wYNNcB(2}h@YyZ@4{6(d&!!mwPtf7Tu#A3zXs+fX5NXdfY zD7Okfd*R3zb_i9O)eA;*?gYT4>VkE z-FqI~kkxXgLDNB`TldNmV}%UZAK}ZDF$to0a}8rVstxNbD|QysSkG;ERCk%pk^Xm!Cq3(Ta@zs%=4)MZ9+cR<(Ot*#Tp!;GtXT~F@`ysq&c{{Ygh{gyz$A9w3Zcz+76nR&2JTh$DG zrgugX!SY1z?Q%+SI`^e%5vSk!R@1uDcKg3t5McZ+vLupJ`5jNpk^ag7^A4ah^J(_WS<; zO4+bT7@f4E!aoY1O%lSPeGGo! zg9mLKoEM^44Vsa$so{b*5sxxGyOh|HK!2x%Mbe=$Mp_6vYc?g&47Q6bapNeYGb;J9 zGTfUR`;rjX_;JLQ1AwaP)G;(cb5G%K&4Qm)%q2T^Qnnw4DUB>`W)a+X)N-HNN2deN zvXdOKzv8C6Kk!!c`qEFcHP@{~E+$8U3^8`@JDExH6zOd($JM-dIDVgnHk`el17&io z{1iF@6p1soDjQ%Bse*x(7#oh!4-0Y8yf1V6s=v#SMl~Hj1%80V0~m9DCs9!!mSK)a zu=vBUB-}c}Y;CU_R`T3z=iyfVSlK;QhCjj6qSXHYp#HJqX-OJ+Vi{ziVX<{k7v=3> zJ8_k76~y!SQk3P4CY`Xa!c(I7OcfEXYQRC;5&mRfkUT#aWC`B_cykWMg2<9WyZ=Cf&GSb-ivSPzOHBFtEr_=#pcfIuj)P zIyyf~O+h9b)J)Md^F?(z6!yA=5loUpFx4{MU+A zFfgyrS5n9TZs9}I*bOwcyht~NNf-`&l<3NWjFax5i#YmA=%!DO3Td+*W5%jH)RLbr z)K=3NCum(|+aii^L}aMFj<(Z^n9ZG8n1Nn*E>6I9P~(!id0CG`^CklY1S&A#_?Js2X=_b;D5muj(oRMGv(!n5Ly2NI)ohDZUp`=(j#=t8 zzWCiKbl3?19}lC2?eAmA@PPxKsxVIOH0TSN=gy+T=@+CRM!(feN}dIGr1`3voH|fn zZlD7~)*l``jp}_ztDdT5TeQd#J2~m3-Ye;kqu4D*A2tJtSK(Nq6CCvzeAKba3YGgP zY3UT*fU)r-n^yEbp$DIJI?nGkJ9+lhY-U_7AXd4#qkLcIK-l=mIw0KMz4Dq z2J5x_d^zT~t>9qc&y`W_+h?EOLr>wc(d@aBdZX1upc9C(3QRb|Bb~0I391;evWqUZ z`cD<+IkK)BMA3Kh)Z3G%8KWKeoMFj^WWJmK049-5Rc=2V)$(HO^2IGL@`~k>H1fsJ zk`!<3FU4EF!HI3{5!HmM6k;?X2jj)Up>RDO{yN&Hv-_E7pr-nDcSG+DdUl{ z49xm|v?|T`aCFL8X^m}VSe{frC>d$gvX(Z!)Vb}g_|V>agp5bO^rsF=$vb)W)GQm( zCPC?rIfG_gwV3fd7Z#(cjVUo~E*e8LQcC-DbW82E!vmog2Tmcq-gUf<3lfvhMJ}+( z+ig;lifGHDPy*nD4m=+aeuQ{0KZ6vAhni z5sn=2pmVuW5TFR59}fIEx(SwHkVB8-B02WUTpF?;GC(dhB>*PFO*G?|8LRRICuYGo z(2yDjE_As{_qeDpWnjgH1KJ3$C+Qw2*kyjoE}R!?K53 z{{TqYZw^RX1Tmli&Rz6 z%M`TrD@3ecV=r(J-(Ta;CgDlMSBkX=qQ6`CSbBeKR(w!W;?-3VEOAoIDkF+bsD%Jw zDn7T=oAB^&1;SDU;m=hUxs|q6B;!HeIrwJu#cKpK)YWh>1Ik*dqGq*=7QA%qbU%L+ zIlXrwPzOHBG;1NZ(I=mMJ5c@@9Vet!c-Jt((vLBurKyG`GdFf0qaP0rFK>7sT6{;J zWfq*Ngr5kdRuA}Xbk7BnSt;r9p-{f-ViVU=w8XunYabxk`wjW!XAVXRrq!1;MAmqJ z4UDOTGqzOCIOYLQT`N>pVUW~9&`l$f?CcC+?j-B+`go}s+lwA96qOlkX%H#KoAB?; z&{P>4H)B@?gtnfH2Dl&wQ4qKn@#8DboTm|&v@zpY>3DIt*uEo~5`EHvT=WiNE}H_#9xyyj$S2vw z4d*Y!$3Dukvc^u@XQTWxa#4{hW`?Y~AoHPs;mBncHVf_^-N-y)-Qjzm-A=caH8>i1 zru;K{aI)S;Z;+S)JvB@*$mD^rg2pw{#QZpu`$==K4}a-T{{SXtF+T6slvsD+jnMY2 z6)l8S_EdUEo||Kh_PE~##qaIoPH$z>a3h~(S-gdka6J2IRTtr<>Eu$+ht^>Avdb){ zN^?%o2&0V};>5;DBgFhTm-|}yICJi+41ot`&U)*y_;Pd@ERfAdT#!mz$-PB5YYSfA zp$5m}#OHgR1atDGh~4(~aObYM!}xM^8~qo`r^KnnISorJRgs5+L3`K9ku z;9-wGRO>klMNoP7(~c+jar%B9U31};m32rACQL%LL1Gkp5Nbz$Q5(^CQ-{m&s=1Y0 z&Lac`>W@BveobD~v7pQCtd z>0^dt5}$U=ibj_t@ao%n+XKWXsr-nm0BFK~896T(=}kXbvQ(_UGl*j}IJH$se=r!~ zqmBYpSbdV(_u@U`y-VQ=PRjOQW>`^4+h70H&G?Z~32-c{MHS$dw-ZQk`qjSOaGXRa z_z+KV;twEA+mUvm!%xgq-Gu494$8nrz1riIUnU*E+Ap-=LHazMrLe z+LTMI{{S%t9^jjk;Qk|vt#>xz0D~UUL^;m(Tik)95gkUS(0(@Fo$*MfiY}VxI+urP z%>bvv&;rCN-}Ii{IH6moa5_Drh>mdA0ZIH*@sjl6RZ|>Qy)({G%Ex?OdSTAMk9OdP z>^SRtvv2{#N0_G0Y~Mv=to&j+6Nb^xi#|fm2MVIIRZ5W1mQ;HnJ7a5;^l`*)%c?K{ z_SF}gwvjYDbTjd1=r>ns=WMfKDcKM3era@7@9L~=_=t$3O`pk zB?HMB*Qz&t&olZ@SxBOhf+{{V-@^v~ha{P4C=z>0bUw*LU}C*?-!zt!y(ujWjF z$Jt!u{Biv=&r2Lp^tU_CRhC6xBM(hQiT(coqn10Taxuf&E6L4Ro<7Qt7vrtzk_i%< z5a}*?6T}6QiX1k;0c&oNyg1XFp?4TZv{lucGbxXSIKlYk`dqD)tbG{IRVfT&wlOoa*d>WMQQxmrK+<@_~Uw8QtbysGulW=riz}WaKet=fh0Y}hi+-@ z(7IB5Bzr|&jOCFsJ=B24e;59RW0cj@xHm*|gnLlc86IpotkPTtb#_1Du^d45<36D} zvGWvRZ@h_3BQW2^>n71w;dr0TE5|9J$)DCbh>`KimAH|iNDl9pi0IOGC*51?!rQIXTMhuF z&$5hdv!uG&(wO$pE7!kOSp%TBjt^6xrmxN!!yUBKuo<;v&T>|ygMdMlPRFW@Y<+qaf#t}tcto>_JvscTg$l~H{o7$ma4=hB~vxFZ-v@a zQZ`VP_?FO9;<-0~Q$omUMPUg^Di-Ezf@^!3WXtVi%L8ZPE z_@w0OdYPk6kmEAaQ^ac~hKj0zRuah; zKhjLo906=p)?v=uI{=DLw0n6)?t0h9;Zzy&5_VUx{{Y2rp}3kz&C;CBO$|Qzt^WJl za8qz^yX_ICo;+<^j^ak&g*e{wB=DztkHu@DIC!k4T#cJ4RafM(iZ)C+qLwl} z?ZrRYcSs^cyp0tTPw{ zL!WXTO#)%_RL0Dv7g~~D87wtM@$7ADo#j>vyab^_e8mx8IBkq5V@ke=ek=VD>W&{r z{YvN#V8P(3sHmf)!?B9|G*2wlgb8E;NxyO1mcHG^qZJ%|DW)$%fzw8MtJYo#Qj$qg z(R^`s+2WFlzJZv6Z}xmOzX%s^pv2LmR_Z%&raIqPaba@Bh)2>)$%o*ut4UuyRc;>~ z;4O(&Lvd}U`tkn&%YX!&O=&jjAk7vW`S{iPe#yA>*+UTM)^5bH5d;{5;#e%0NsLE4 zVUX_JZo^yf?VZ(e*5+f`MQ-LH3W6yKH{)&T;bo?Hx)+`vI*W;2s_=g?${p8ISoRm= z$lTXp$@o)8JV7xSR|>z!8`J$HQ>yeQI;0y&MW~+&Vm6Rin>VoWc8QEb|wC>#27q*XX&~Ll6t>Rx#JUp zy&j^PU!KANvNx8+h3#*6TaSNb9Xx&%kNL6&+Qo?eHJt&ftXga@)9!VojzAhP^|&j! zdz<%b0n44#bR18@wlgHDRP#ajvGne%2gPxL(7fXoABEGyh*!ih3=9DcM6V2CMb5jU zKX(~cLh48bTYRZNxdccXDJg{hH60Jd9KIdUTO*`-8@k-rT!>VAD$Hl-OyN=6@uR}) zYicWD=w2>xnn3h(&_jq&w5wFde)Vg8n;zULUf{e>-|(YEXY2%EpN(;s@vZ5V(hAQ` znUm%v4S5p~!*;MuEoS)k<SM3Mx3!dR z*SC)xPT(yjLcSE)-ekl@XQcdPI#E|6(^UF@&5}=1DtTl1h8w!fLW`cj_6L^!#5yt6 z@Tv^$3gPjme1GwN>HY;tOII(Z49P4tCDsEDF@(E-jOb0TrmM$Mx~?cjtbHp=%$o;g zAn>oo%cJxV4RMD==wE4_7LmQPYKFQP&FQ+!W$9UpZKFVQR!qG7i9(1gi z@m=W_FNQ%}-4D#-hY;H|ZyAO|wXPI`rrKLj4}K+ka$Y+~_KI58e%fH;?4YWv@m%TU z4P^C{-4e_-5ka~%uXm-VX%se!R!wy6&7*MMnbq*8m%NQ}9~z5|ekYg>RUw|Eqj=Re z4OtS+4N;Pf<_O~VWxwv*r+#}m%a?3~g;GW{6uz=WfB)8z_=m`&2kAnhumcl~W)4Mz zt`&;0`^RoUyR;H+75*>GRN0yT0CG>C$kx04X2Fd4=M$@{l$VYaq)Ku2O^=$SY20qN zB+Dg0j*~$W)_|3Y~1{C}0Cv7LF^2Kvi zMpBqT1{JxR<<66=icvup@Emyfg&GU6Cz9B9^_q9Y_@Uwh0KKK1XXooDWM6w} zK2@~SUL#)W&++^!?dJ&t?W(cseA#=fIpZkj919}N)4Dk%u1re|tE*b`QCU>2P|_h) zU8D48L&05wRKrCi%?IxsOYQ>^6cknAbqK#J1b0IzgU?^K7r-sOzC2ckDvD~Ia)w%Z zjDD()o)LeM#NI_9+hkaLvw|(+SwQ1=4#3-6Ww2H-r+mSdW5MEzA1hFSq$fgbmbSh1 z9P>_U#+-G!MPV2_3WsHcls7Dl32m%bOMO=2r6@%uN-@HhtCeXgDom175$2(d7$x?x zxw*Ezh4|5U^wXiKH9sL`2+m-}DdvI{jtUm?p0I7&8gMRwy`{C~Tyw)(4N0d($qXbh zI;yvr-di&U1h0T2mG7{teq4>T_mwiV3yb0~P8B5iC?qb;`{s5}pxhfCGV`7sDMKg$ zMrcjMGFBCbQ6x}OQdCqtu?Jx#fcLlD5q(dG5eJk-I|;#qlzFbk&RgE+T@d1*(&LBNeSad*Ov*lL=C2@ml14# zFktzYJ>n)@$BbrNew1QZooH!fo=Tc3c0{@C4(kEf4%`!@ZYIDYsP4HM^09%8S#iAu2BvY2?+j)FP6nXuPaN?eOF7 ztOK@~Z1{TUR~Zi$^P{SfVyuMuX(L8du(9mGY7U%0E(oQa)}hx+Oedtc+hwdT8H#_D zp~tCYuLzr8bcriM+BexORGub&^i4l+Y(h;ZCCW7!erzJ9nlW2YBbuG%Dg>Wm;IQrO z<HAOYmR%`fOL7HfB+~X9qCYFY5BPymCW*b&TVN)YIHU7$-2gi}_{{RU}BW(Pr zOS>TWrjK9Z6lJQ)89D=b;D)kECje~({G8~cUlC>_h__wRm(@Sf`HFiqg4hG5wfXfI zf>Bae)4c@>nCq!gyrfXOW!u=5_L6RSCs{g3+s1;gq)sA=js=urn-;3Y)&`Dw;;*Bq zM+ahu!x?*gPj9D&OMk-@kg^DxR`t6mQc`A$Ey}c%#ubK@WFT*F5rMbH=asQ^ka4P9 zvxij%d3!58CR4;FkOq=Pns<^m4YurDTn$HUcw(n~UR0G0z>`e5-vPy^t*eU+rAAt% zbZI~e!b|AF-$yRe#N$o4)a<0@L#@u8J;xI><=lRw0M1!zT6)|U8laS;M%#kzVl-uO zb!9pcq2{lcY4*w%B_^wE^4nNaOd8m)p&ebxKCe1im~uZ;upB+J6+{9I<(22!Bd83% zTGr7Sdu(C|BUCyYuDpjYGWW8#f}1BtJryN1^LOm&Tm_DBqH&Am3|rAwCxu}6PD5Pf zhDV9lROGzp0(EMcv#j4XTbQ{Rlmxe9^?$`7(linOUSMj<^>=ZqSf zT8i9@1yq${5^GYt1dDxvB&vHz*M+Bdf4@HJGIKZt$Ve1kv(K#lreX5cQm$1sbl9TL zh03j38GNdgF&*AwA9xK^fyLJQrh;c#pGwi*5QM=%_t7oR?S|u6qhs@7Lkz2)o+?$N zNetFh2J9Nk-(5U7F12U7OcOL0y>K|aKvF{{(9>dg-Wwazint(JvSS_5Rb7F%!ocxU ziXjG&2-Qkl#Xz{NMQu7zM;FV&kgCK+fFHQNh|5d8o4N zZj1}tZ_Uds?c#33?%{f_Cr??WZ8AtybWtkl8NzT#Gc0(7P6RQWK^*EGgo>nV;%~!i zvaS@4&9DiYu=-qy0%a^xK}4(bP~jjL{A7&Ru9o)g2ZW2bl?pU!-Xzs@;MsaiL#tWh zga%PXP-Jg+`~XM6A{~a4M2kkJ4G!Hj%U*sTjZ+E%P>^C$sdihNluHtPd!8k^c!DC7 zTcZk4;#nS&OkOlNTx%;uB8CIud;KEb9NHh6s+k-qr!M7Mrfg1-qstuyOz}Y*Uuvr& zxgdQfUQ*@gHM@4JyeBSI8j0k16`dT2B$6;L>U7rM4l-XPV@u0APfZOtwnAF$jg;!D zXg^P1Jz7I0h(Dv2d0Xx$h*0^~W1_qmR*-sVn`PX+PhHebsMAA+2xY=vIMP^yU5s%6 zNgc1L;qn|IwBtnupjb^ zgvk|^i3EGBZS-lznRx3nuvL_g04A)D@Pf)1o?FWPpw&ZC$y1pyhKXv${LlB(6pd>h z;dLJ#26wgar8WmeD#@83s|x?uoA`tvY`4<`A_tfGqB_nm{{T$&bgP6R@r&?ne0?clkEq|mA+>mXZfkEe+6j!sh1BuW! zTaJR5iDhv^Qjn!6Pa7BYpjK@(;A(mn0L{%8I-Zmg>^>Ng!7{;1f z2sT!--vdi6Wm$aTrjGoU*PI`0Y%G3rOKu z{FoB=w&1op`1ayvA6|iuG^NH9#)G^c1B(d7u&RZGu#U0>c+ z#8AnJ(^I6jqF0o(o_yY6*Gm!sy~x(wLXg*NMyaL6VDonE-MbH)x3v3*lwI76Yu(TUP+^XAw;IR4 zo8p3&*gg>7BCWf5GR71&_gdoT!-|@_34uvVDmcWm-AGm zR^?RR{X>Hm%sAe_)H2~Tl(NknL4<8~n2KDX1o5K=Z3@p&qZQQ5=|hpQx~MS7BCpNU zLr+VD;Lw=TDoSY>!5cC!WE%)XA83pA?ns7|>ZJX&XqOV$F}8@MXG&^wG+2f^m{IWz zO1UJKS?bF(w4{<xwuPBQg>OfzO*#$pXN6`Dn5 zC!V2-#|{%j@c3!9i&*g7U5yI94Of>qzM~nWa-~av0D78lxKAk;Z?L4gHl|D z+Ryqo=wB(mSHN{Cnx_q&eWT>eU(;B^nAHMdZtoMz)0;#vt&Ex=g>i+;2<|(Yi%PAwL%0h9c?9Z35$rfSpd+>mMC*3QO0mALn-32VHlPj zIjh3)Dp?s_cM!Wx>^703DbS4%3U5${P*SlV(XFeBK?+HND(CuTjby)684<9|M%3BM z1&TU6)0S$;l`j|!m2|#lWZ1E zk*ZbV2_q>*2W_mZ3tLS%a@EEZfHq3Hs}E0dNAgU?gW>e`Tc?&9il(TR#JaR{1{&$E zmgSy&6w@rSQlKfvC}23XbUEUtYCy)ID&dm&@A-oYsqTI}X~)3QCY^1)q>4Kpg8F4o zmvd)Suo;m=X@*zh^o-?$DlIA!4&kr7o*X34?+Tkq8)Rf4R zkdhCSE2$(+y^m(&_m0vFbj=^mmh}4%#Bt!_mNZyoW%7|rKGJs`Pk=rh&G1}i)zMK-JZQ}g1e1o*R47eV4kgC1>3#SiJ)4HmKr;f>mW$783 z;Q7+j;#VqsZZ3Op7Q2C~Z675b4@#?yo6}#K>MvUBset}z6@1ZAMJWmlQOKpOaqX}i z6e{cXNCt?M#3<2*=>}WM^mrC+j~Aw>IK5Ubeod&#Y=#tq5h;*+O~_s`cC{6PHbpyZ zlmr>uN(^5uVN>IH8&R1OonWY0gs2JLcH3wc(%tz~JgjR)2{9GcNa^Jy^*M^H1$d#X zB4~|+d&r>JA8q*C*BA+_vY! zB!4!`IUb2NBSTq=%ETekHj+`P_z&a6o%|@pC{`&ITu+w2k@b_W6p2o0W0f&&gHdRB@V&N=MlY=0><{kV)D* zlftL2mEIg_Q*7!$!x}3dpt5{89AcSOV_KSanw-XgncI0=7VltJP8#K}YBFgh+c87N zH`81(@VuW{iQ(yAQ56m!O&ttd+9_iBB$IJFLh3=dw{gPs+!9Czp6>htYQ;SSV00KJ zU(cx!N?O^msw&w+Gdd{w6^v?6djWB;0$arA?NE8+M;TfSF2DcK&G>;-gM#$3kfAck zi5Y~E=n9NBsIQO5kXG&i-<*Gk<|=K>aBNRc%Bm9>z$V8rhlLN9B}~-R5J@7fg0drA z6XFRZaB`LDqGypR^Po#J(#bZ!`606=B5~)XN;#{< zQcVm<7B4jqFBqU1I^jyMX;@|0cHdX{^{icu%}99lN}ns8cwI>tWnXo zPd!yMl+pkrSd$K@jc&FA_HOp$caC@r*O+Jpf@suZ@l(M?TZ7VJh2=(8hs-+}8Q72o zyY{~dnmElXadH8uxmKQ=5zP5YDw*R6Mf}y|s44ay3=*&n4YfRV)ew^vM$|QmLgq{d z6jIe0FNrU^2DgVAc9)n1D3aaI-s0t>Os;>VMXtym=!gCKaSH^ zqcmnC405W10Wzr!ZSdif?vRja3qu+*HJLXEf|w#Aur}-t;75M`-uy}*Q8e;^iU+V< zp+{TQWq~Bxzsu^SA`z>FtEF9}pJn)|$6>lmmf>_XXKcSyfnrzM`ot>Nuev~Um zs2%ke;d3rXld_jA6x06zNP15#PHoNki#FksoV`?(SbhnHF(BeHMqWoGixCp;0Jn)G z1EC{VS8|X5kw9+02HL%?u~Lav0*;<5hGU<|>oI&bkz}5UR+bo6FpNp0k@GU*IBpw{RLx#XOXeD?wf6}O2fzzhanH{F z&YS$8?tZV}LvSiOXV35~2)pre zOk@^S5@7VU03C0poTgymD-~;0!c275E~Dk+^SO~~);6R~&?ItzR0V;ROI&I8xb3^U zDYw%pG*!Jjbo#P-yj^PGGt$dbRWucLvhAduV_?4M((iAphdG770!x)tk2P2CHSi+3(u=@PqTbDDc~+Dd#OiO_g$%Si@$5N$IGmF==QLKy4Wq z#Ps_~KFba#xprJ8uWdRxI#-k!- zh#*gM=Rz4IBWRJZ`tqX7YuF2)hZkgJKbTkezcEOzq%uFo`BidtCkdva%2{0_cbHZ~ z43jNNC^3T?%*?hMh`IM}cr0OZsG`TrK{Qa%;kdn9PlQD2PenPx=W3f0eA;;`xB*Oxd-WkeD`+}#Jb_ke@Fw%4j_qLZMwbWK?+*NLFH|X2YltB}Q~_hi zXmG3|u_F@GW7tfTH6C7yUYeg^V{f2q!xn)ii``Tvm7PMTpr)dfvDzwPm6Xe^``X7# zcI6pSno_i3McFV)=Z=#Ust&PK#Z5Qv<05nv;Ak(IG^D6Vq8(L*QsWh41A-T%s**`2bt7o<1KRf_SRDu;>%kgG+Gwl{ zYF1myH4tOTHZ2muaKApB%N5GJD+pt>AKv$^Z*M%~!%h`IgQ{pr=|)|~mRx5s!$eyL zsdbkO!Dgr4QUc)W!(06q(}^xr3<;%-pv@iMPB>m5ncFed%Y>{+ieT0FYDZ>66k?J` zkdi?pf}jtN2y+(!L=&*ljk+OIL|dsjFB#4Kde7KaAppYa@Ty9BN)IheVrN+5S{ZzG z>`C$0hc=ffOG!Iv9m{06O)q^mWXwM=byFLIHU*=ClMSAldP0{IO!b&@$bgM5p^3l4 zn!9&XVks+agt?7bc1FpVW*wZAVA1}E7pa;WX;q0x;v`)5_-XOrV)6B9gSL;@X(MF_ z9Y^WKJ}-#lm@P|hr_H%`dK!YnSv;IlkSklM!1Vjf+X=qvW0mjSoCFq#>Hj_P&W`b zoeoIClxT{Pk?_sc8KdRn4FIg(A4XkJ3xYu!a+f?Q`*iK4-UkoN*X@!MBs7w$G;Y7X zRY0}$;w3HxD@r8A2quLv{HLk(Q#4xNHpfS9%CAXw&D~>{_2FU|wB8j;<^_3^72~1Z|~`H6q_1ufGr=4RO~_tLz4c zuR?WG;@NYk7?~w&XtBuYtK%V!*ij^en*cmOw~qsR*32y(LX5I^N!B`R|Iu>%K`GHN zZkb4r<|^WG#~ZI}wi{Y@li}NtPVSHLgXQxTHs)vcL(k-Drz!+Xn=r`ZW@%npX(Nh7 z0_4C856go036n?yKq6=-%`(!%gkmA-!p9XzUCsNps+QyEHX}|dZBnSF-cTY<378{b zb$BdoM?oAD{IvdjZmKL--V6!7!31l{6)Rmd1PP;+Sx+34I4e`q#T(UO6ctj1?hLfi zcLT8lUI&7SRM3z&;TTbR&bUxaB3UFmRp&;9M|A>YZvHpnwY!8GCb~sWs>884sIYR= zyv(twV

QRyV!CwzuOdIMta%Cb7pyRJ5|r!M4*)Oz5kj+ACqW?cD3n16L|BPFa$I zmk7ir6HXK26Cqdz>e~05)W}dp4AdRZsoB4EVuUL18;|_*jw1(qP1AZ4Zaiv{Uv$~YX zpl1}y=8GD@s9{MOrl7mUQ6zg+!e}<$*B$$DcyJI;3QAK3gevT@{I#jlq%6%co2AIG z3I&Dx_t%YglUg%M&X(o880KuVio(-;$i&|bsDab;dnBWow<~yqYaS)Mcfds`wQ5u- zP3kroUX}4wB?K|YJdZ;aOtLg=<}HUoYgi8+7hAjtrEfQkaHQ4~HXl=(vPm?8dUT%< zn-PW1(>Pojsa-=aYu`_YA1Wm#s#^hKDQ(qGpjBeIezq8}3R)yF?T(QT=%Pj{peRi= zP&DN&Z30#?r><@Wh@wZ+Io^jlVkVlHc{LD}kxN-a85M`xKLRbo>wq*-BWm&WQL}25 zm1&H03SFXaJ7FLeZ8gx?>%xE)OMn_^0;izGYWlVE*kwdmWd8ukF$pDS_k*aepg<4- z-(DFJ`zbv%icY#VG?{KJXAsMH&OIwt&|y$VAIJqC@5*SvL?n@Qh-}o2PhsLgGMp(8 zD9N@8%uuZPy9dCrn5gR~id@xLu~fx`qW=KAwDPkeJ17=Ve6kdK2eXLCDigw&%2IUB zG$mE_F1~C5=`ifDCN)sJEwP;wYa=4cebR1UQ^XC~f~-v_amY@}3n_CQRymARE+@6+ zq{DFRDxR7aBg+D+wVQJhsqA>=%PB|^(^_TSYBb%R)JbkjJA5v0 z;jQ@PsKRT{ECaHYzMpW~NpYO(1x!gTGtWa@<;{x!0KVmnk?{Q=Eq-=Z+e`yo`p<+? zvCWMWgjt{x#~NPpGwuSz=r;O!t4NVdt;t87MfAs%mk7zYRy$CQRY#21W-PTmKETSX z(?wd3YiLVG+W2zW%le#(rd|e#p|2Pe5Mq~*6B~#5gAf3yK+eo8Ep4L5g)N#fQJg3N z&e@z%s^CLvRY%^x~ji(6Qsg0=_=xo?%PpO zQ&t!Ydo~+zEu1hG={}slvwTIILB8nVNmKTmN3nuDHxLwME4;&_)y92KpWj?VE*R zL7Sz5D3Wxm7Nv(1t)i@uMf0_>QY2H2!KIWjLP_>s#Bkx%VdY3$#%NLX6<0v;;BeB! zh}nNCP{QdCVDrTTY2N2U#MU60CyA$S3B#aJ1zSWbx@kaNkC{nC)s&8;SR>N4#m~2~ z9A1eEib{UkMs+6;`Ks7(h21REm8S@VkclDQZEy8Q6tK{lHCLQ~DZ3Mvz8Y*YlC3Wc z?N2Ev2k50|P2%1n>v6~0I;7Hjg>0ohV2U{D=K09TnGq$WnF-w(2XFu$#fN?)3Op%D zP7_Ezh*njfQ5`0zSiH1c$%4~3MkeU^oiVdtx4b`Z6kjGSmE}z`uiB*b*3q(L+N_Ta zMq;VLl;D|}BCTqQcAjal!{!O)c;Y00>=dEhf3!zq$d^)F@SYSjO0?oBC7wEQl5@0J z?jK8s3S_8>u?R4#u#Hh1F6Bi;VL=<0cBFen^gPw7oVPlXWLBOicxgLor@Glm`jCL23!*!f-NVE*lf8MRs<1a;y638yAFvI9d^{9!KAiUp_4G#*ghqlS>rB?`u{Ih~X)_BXh`q#N-C!+_&U z8bXB|u8^i>{&`0Dd@)m0G&SyyBq1i zo6FTlY$gDjaO$&C)7R1CX09r6H4SV~xw$)1T5`ZJ7S~ITG?bV$t(9%+s+j9m0F_ye zo|1P*aM)HNYM=o_6q+QMp8@YX_VBj^*?Y%M$}PP6fU7a4nh2w)k(FB ztUzn`@PR!8rj`(9sG}Io@a6uj^(u7?DKi|njV%-3aPtyN{Z}J{%QlH^G#9&EEYX1U zX7kU2Od1Qq7QYHi`Kv0{PK3V0OC!%uJWZRT8(N$p?)j}98;OEVm474k@7b%=_u}jG^_MCRfpl3cdBU+Fw@PB z(;~&C?lAOGsJPT7r`mW~yoxF*9aN(zY{HFy|I&2z>U``Erb!h!^1q!dbIi@|hW=ZK z1xtHubUcGMb5DADW9BMq%z-E#byZJ;%`RfY@fsuZmGBfus5e=F@>RoF_Xkn+a9p>N zlLm{_Fb0b6SZiu&Fi8U0jYcgk3jo@$ms=xf2f&^fS_GBS8>LEUY3a>R^GrJt^N=a0 z!{$nVF54Ll4A*1r?l_LNE?|n zA`gg6@u2gl#eP`EqjN0YQVZx6U*5m8YknA89B8`d8h*?ex64#X6%=bMHcgSCEo-IN zYvX<=iKPsI08@X=;#G82RP#l#Drcr1TwnvOWJ)dZ*YoCv6{Q*3SaaPyEfq#0Oaw_3 z(#Fa5h_sf|;ioLX)CE%G3N9Gjl<>tvRteg*^zyVUKqMLCI$ztT4w#cgPc9XYO%M2X zGhEWsnpZ0%QB5`2f)sg9pnN-lr;WIf+W;x$y@dx^pEuUynWH9EAWAB#P_zt`yO}^$ zC|HIkQZ=ygzZA5{N=T&3RH}wtQbZC_d6fxTl0aqiHtrwe}qhZCUTUegsLryZp==vDhCQi&*1% zuREav>9CLk1`BiT(4HJ!f|Sh^Fb1q>*3|z1CBvsmWUrDbLaPKW8BNJw;&@UQOS`eO z8cg7s3Z?pyL!E2sir}$P*5J537VxuTRWnpl&a5r3lD<=KZxdx6CyJbYThcboHkK9M zdQjz$<6|h(K(!`1+|^#u$4x`-tW=S(HY^5!C>Bw|*4tW)4U}rPgK2}dfR33QOC0L1 zF^g7Wrk=W*3JR&JssMMW+VTrsy@9)NZQuxK0Z47hQ>4+uro^k7oBRp>n_SUv2Y<%x`iqr2nOKN7up5=gah#Atmcv}lMyu6 z>Ekv-hV+G+c0^dQ`if;FDtS^6~j9RlhX+ynLKCWsk?bGn^;E=^4rXhx;G{~zPDpg3W?)zBo zCfxRtmv+-&1-C(_Jt4uerec~IL^b$rEK^j^A_sY+SW3a5)Pl%BA5RuB_kd}ahzT@z zeF%Kyy*H%647MLsaG|k zGGjE*HAq_k1qFAybl2S^--)+*v-yPx{vVj9?_M3ygR-g{s93~R8DlQb{K2bm#lo=0 zhG_4#qZA0KVcd;PkF$eDlMVoAq__+kEBPKeIPq*rU>l`b;HgGi4|{g)$92IWcw*o< zQ!OL|G`Z@w1vM@aE+suksyMb8gi*x{i*5pzD-at|eb?8FTD!1xQGPwjnH)ASa58+4NXolnlWg%q$l?)s1F9;&go0bq*SFRC~OV8!zO7nP~;Wu(jw($SFPYRfDO=59e5UDu7Ta4apaBCBU1 zWbmOmNYl2f$FA~cJgb~=DycEYp~mofnmE%Fr#?c%}X z*-L?K^uXIhYEG77{UGYD8-?SMN&KzaxZ&8lT?COdEC3|v8o=;ai`2Z#jkHGFWe$y1 z0zA=$QqH2GLP;yCB(8+&1($WSwV0kZSW)W~y-)Q}@6nvoAM?7*K1o?CDIvt`(4pNK zgZX2xX4)KTt~91d*UIu@YaNk=3S1AfsXA~x!*C*um4ToOKIgm}Gh~b}8^SAv zeHCmN-WMwkZ1h#Mkjb{)h-F}Sr7S^%PBKBF1JufzbDS{jK01P2VOJ5qc7HYGKri0@ zSUf+rLC{4P-X9R7!ZTbglj||1kO=0>m~~PyIs@}H?ruH4&!dE)qpms)Dl5Ytil=_1 zWQtj`-XEG1&5swvYpW{aomITIQV0s$Z)4oA!v4+;^5>-KG#0&V=>*ZD^gxosl5y%P zj5#VAJZiF}m%Zcod~0}A0;F_&>e)6XK%?)QEVPtR(^G5@^PZ!+WKm)3gvcLqz z4Rm=QFJV&oPcqa?f0&vlW+Wq~y{&CU_=U^TMAP4w6bNG(JLfX~W5#my{{YFeNyIBB z!=^^G1~pZTDN~^gG$V?Oi>UJa zX>L-W8DC7-|I>E$xra|rlyWUuVZeDqT1>&!D^F^G*pl@#T4GL2%f318j%$f zTbPMcf26++?Gq!?k-jhjmz_Jr>Zvm3Ei`CnStx1*Oc&iyY1?2wcN@48s?tUjXLAj0 zO6HD^RQX#PC5${~<7u7*uu?sM5O2b?BxzWqcNGdnJ#_?9%||3}a#E$4Dj{;LN19gu z01jH#L7Go+xvujbF;1D9zJ_RGf{Kxf%P4!ZOsEM1ZkE?yk0_>yOx2S7nrj%;a8Xg! z37O`X6{GU3b=MJq?f#B6-RdM$>wG0RS1z#6QzRI@OGp&SD@u}IZN!@2-S*!6y_yC9 zRW6<5MaK?{`GqbH)e?tPti$M-$Uy;~wF44Qa0d>OV`UYnNd}Er!=u0rOm#6U2aLlU z&@g2!u;@+wqsQ68u%e?*sTi6qvx>F3->mcewo?X`~*=}lMzLQYng3T&}eGf7bOIIAp_TSCSNrksWrwZR|{hY(yD z1X7kj)I8`m&AFaN#vRs_(9%^^DW!*T-pcYdwLP!jl|x<`rK@upp=T~ER5`mS)HKA2 z>*t-e>aoc9Eny&A#^1+@okXP5$W$y>KU0~4JTolP!-dX7mHP-%+iptsBibxU<+8L& z={{w`ig!jQWyWgcot7!QqbYZ7gK%Zi=fvNFJE19}MpL$p#u<^K#%mzW7`$_~6BF&F zp^iokh_JZw)DL(<2=|z3dk-5DE!gnUgDEQ8vX|MHJW*syx*A&Z1}W6sRv9ZWoDo!c zSZx(MM+htcvajh>DvtjEQR6K#r5>tSr}UB4Kn+$SSv>W%_0?}xi(*Q+ob@uXw)J&V z0PHMUzz+@>B_LoaGp`JRTh47*#3!lE2M2!{lUC)|%S!68ArWxK8Zt{2+^37Wg=5sgdq z{{W5CLz?rGye~{EC@2y`sZh+-LjLi%)pb0*@=OY&X9EMm!epB2nFeCQwlAj!czM??OacY`lxPAKDkKUtG$?~gN zI0Hm<8VzbXvbe8QQjupSnZ(glQv;-ot$59d>@G*u#SK~MYHLni%aJs7@`fQDHbul~ zTHB1cfR3SyBS*RJcCuSvdiUWi;(u-IrA(?@^`I`h6?&-gXy;U+bfKa1Afa}V7({9% zjoFX*gqI-r@X4gbCUJ6;Rt5NaV$sW!F&T#AB{myFD}2chaQLPmLDI*=?%`Hum~hj! z-X_H={{RpPn-l5&Pk_o$!H&ZsgdN0`6|oXF_aRN~&1A0r)cJhHQuT;H2aQq2K562~ zS#u7MnQ5^6Ckv#e_s!W>m17@QxxrdLy3G})3LrC;Y6R!DTpudxEJC_(sU?wRg|bPTUb%&oE`p4 zH|DyWI}pcVNpRdEBrE2!q!Sq=D5KrDP@}caB7lMn4U~U@Fe;*bM)d*==bNy+J`wUT z;JCF)Rn$ZpQ&0-F-!Z&)4F&sfbCuhaB2PsSUX;uVBNX|+AIX`r0Elw+X0oQ4T2` z%1XP5_idhbCnkR%v3B}^(^gDj0K453?2 z{`Q~5+UnC>x*PHGy4zx)wy2=7@M z!HyJzFI0nG>IG#zPf~Cej>Rcfl88*?uz21XWES=n-Ul~s*X+#IpE99C9vzxzm!BbLC?(1yyIcc952QJyqRQCyJRfFERi|PFg}zcG7boLw2O7`Bk>&HNSp#87Ow zg4ARzX0D2*qpE4K9rVP2S(LJdQhY_baa-txj*3feK?Z^zn`R+hMUPgs!KlRs_-E0- z-a2uw6sf3CuN4g@gg-Ky5y9}NYHDPpSfzTQB^s^eRF$l!;qH;kuLCrl27IWvb!N3I z@}3)Z=`cxPfER9$rOA`KXdTuz>+DCLT2rZmwlE*ip1-9&NI z#UTJ6Zo)WHq{7vQ8Z>Qxvk}olKcdR$p~7?H8CEr`#YvKtZMmg-8bGac;GkQCo5Y|N zk1xiSWoZ4HqlvHo)Dr!8Q=@dxBD-H{&9qi^x7q$nh#jKeMfn8o$o;C%SIku3n#XpU zpiaJKd`Ab*`6XysqNklHDrQ*NmGdL2L*wiyKRymD+th+h5iMF^P;u1q-!$?_4XSIU zpUxlgXl8Eu_YHn7wM>fj>d1-_x_uN;WOc6$L3&w?;1QuH@!HMsJWjPrt4NA6bI(az zish4672gQ?BS^uG#NRFu_V$u^Qb`j=qy+)fOnqCcbu*+!aB*<^YNHmh`uKVg;)6wRssN$Fk1^BD360?~yzY$KiPp&Xy|f=_ z4l&(|c5$dQb#O(DVG`5ItFo~gHrg*^dz%mi#=LMQL8dmUhWgA}Hi#g9J?`6Fy4-m9 zcRFzzS}{+WT41=96fKgenoHElU+0L}06-8(Gy>KJ;@n8+FlqZp?*$jmq~h_%n&?0( zl#x~yli(6dfp+e0G~@Q|9_-W4sXDNsw*ssUnzF>NQRSE_XPB#4gM1pLPj6-I#ENeP z1JO^msc;GoI=zckR@PzkwbQjr)jL!u_HJFlM|%LITZ$}G0Mc8#bi~rqwGW~f67Vi_eQs~*LN6c8)+50Wk!xhZqB%0PVg4_X(=nS z#xG6s_!T0z`Zg6#LE7?dHY`XRQrc<4)>$qqs*F~m*parYk}8Z#7V35rh+Y80ehtOD%7Aqp6y>@lq6bYC{+Q)_ zUc0FaS6b3jr3*X6{mg@Vf&n^dso{mofi1-&V$`Wv)rw-c^Wd0OL=drR2v(^hus1Bq z82fyC-+_mlmqi}3kd~lPeZz6~lDidvo2ghris?%l4{BS z01kT9tidw|8cx{c!f4(i=EU0)uK*GC9unsW1;f`yHX!H_Hd4>lD%7T3!{wf&y$u#G zM^#L+9U~Iq)v=Hdd+uHm?&^weT$3U`VvRGc3b#fW&OZ9548uhoUQxnffHK!oQb9*6 zDMpWU1)*kM*SQ>#5SUp!C>)hhb-^frT6%zvCJ#JSbLdxVFt>+=mx~U{YK5AdIYcnj zO;GcO!tnShp_tiXljP8Vqh80k<8|qp2l2YviK;7AquTybEi>5v0FsK}i<9kR#f8u?M55!;kll^T7sh^7+&oe3ncMj;}561Gxrema79)t*R- zXwPX59f;1#+tMkf4{O|r&Ca9YeR)<{qaCn~Wup2X1?0Gfwq%f1+Ini=TKpe(b7dqwWDpl z=aR0OFYzMWzF^su*0T2`noQGXYMR_qf~uqeQq|P7Paqmu6_6c$paI1xYe*ul=04gq zbW*H%ZYJmhr9#tHpp;w*Aewkht?lo^q^hdoF`~EDirFja;)*7-8j4~{lVP-bH1Of= ziULg*Uu>cCpqSMrS;1>wqOeoNSy>`7Gc}8?ECWpl?0AbbLY8Y;L%{6SSL zBmHw&AQe>Wi^owO%{{|Q03df42_kN7M3b$u<8X9DziGYlnTwau{K-Vg{w#H51lS;&)JF{Jr9glx;*bw zS4Pybrax$5m~HbCIvQeF4!|1^8*nGR?Hz5$N8?913%|2m^wV-8cfi3;k6P7rp}{L)jkhTPp~~rC31?%fm6MlO%U5_-*Gx~)~fxbD9jr= z5_+lU3^UVo=@JzQ43PPo$+&MZ#gE>3wMM#SI3|TG(T&r?oO10vGMag5DrsevVI-`` z07WC%En<%OHBFcV5&2&?4g8XK5au1XC;elu5?Hhn0i~CZYcoX?D({CQ)Y8o% zQ%heO%A;HDsENKjJXjs%iX$h(jS5uQl+#5K@?fsm2DLPFsPmYCV%qxn{W{M9jF!`2vN-oeDg|>m>IEo^d z>Y96{n-`xE%9y8;)a^}B@j@Ah1q=Ec9N2)H2I3=3W^-dHW1WlEjcY$0i{i|FPOUmm+_1Qy}Mst z{7RN(GfGP1We*ujDu}3?a~D~VuwY0{qM{oErM!5FWK2@@K~SNO8KJ?U%NTYfB8jsu z$H8l>9h?=Sf_AA9i|8DhgRh9<5VNj0Q_F5sK}7{xt_hp!V}{`d8@+4+2r6rVw$MCB zek|4E6v_mGIMZiX-j0terWc%x7uyTGX&x(`v*Wt^QJtFUqMrxu^JH&jVL8})PZKRIXkuX zTmX2{NzxBZIHCbDLf$ctR85Cs5LE?|FEXtnX)JWwx{G*e#)<}^8)-*)3TU3;8Qs?y z#Nv`d@>9ny9}CCd%Tljxek^!&SOifTo$(sAAH$Ct#PJFocB+Vz9R(&C43RlED<&a` zoo(zZz-INMLefV~2zPN(l}#EySQPQakSMOrwQ;%_XExkanmXxj3ATddaJP3LzM<9g z6r(s%4JXg!YJzI>Y*b!e8A&XnQ6i+~O96Z8g6C6Xeo0@KJ7^qUj5ySqJW~sxX`rW7 zV^~TwRL)k;TK*u7w>Kl6DKl46fT_5xb3;Le%jYkX4JA6DLw|LkKs$UcIi!hIX={o_ zRn^hrGSa0?dp=&8N@R))lPkNDtV#PLwf>GRZLB7e_tG(@$|`{sB`qrYAQkBL0N`x@F1l^_WIY2-C`oIAPK8V>V|V%M+?nx<{E@) zOvMr!!y>ye4AJT@eH5D>1uU&`08zEg)Cvf)epslhqQ)_*igN+0qjsPmA1p+S4fX8J zx5v2ChVHmV6iEhXuxFn-p)m<5oAkw`+E8n))3NW~{9M{GrwX)+KxLQ=xzjDQtt4xC zeDe*9kSXLA7b4`_w--8yY|&tHRw?S6sM!8X&G;r}%DBAP204QTsKc=sTF#Ff5=V$- zU@Xc-h|uvDrXMXHXu_#QK!GPU5f^PhQU>eo*HuzDzTv=Is-?58 ziI-ogs;fG?TIx)Wk)fY(+5uKEvwa1|oHxr=rL1VS?-wG6e@={Jz`By2YO#j}TA4SK zdw)2h2Se=Q4B0*;#TjL3GOsV4LdIpm;LWv^I8|V)q;RTlim0$3@^=eEMDU7b_c0V&dW}|+?cbukR9ADZ z(!Ks8xZ&NCQAJma9?BQ8Evxc2Wcg_Xb78f{rFSmxu|j~@0o>n}yipDhDotj+NucX9 z^%kN`TPfkVRdAY0g_?&Kqm@SWc+`LeyB*d%^K1YKK9u=b*+@*&nem*jS(`HC#I_Nb zqn#D8x0kP%7DOd(E6zeXO0tEmVmN!>df<6k2&aqY*k{gq&L*(JCSZ7Ny`SH$%;Purk!b*Wz45mS2bdbS)J)|B7^A_RKI%vZyep{r6OYw)p zWyfQpc1M#Cr)G*fk23V@xk(-eZybHCKvI#7Ch{V9x;4crW}KW zEj02YMMFhXO(Z8p2}*$t@Aif5!nLEuX=8562bCP(L7rtz7f~?^q*)dX~4Ggh*CVL(S)Z=bPqb9Uba*nOB7+?DiA-^Qlw6Ga|8-~mMnPd2nL$DbHJJCr;Kf==z4J-98C1{#S}0{44NN)pdq>XEpAo0W@FVN}`4=@ru_=GGS z;$&sM>!>%kZ8@cTr}k!HKeiN&-K3045>@#Tqz%{C)giW90Zs;WxG zrc^#;)kXx01_gE^vxd3&fH+<@QHFy<3YuAQOq{T}@*`(5h8n3#cRn7{ZN@~wHL){A zSE`tmH6+kYPJFoxlOwy3N!ueJKc5v^qHE5;*+aLdY?+JZiRkl&CWaiVmnw|dbr-y| z;`I+n5k^Omhtnu1 zhiLl|r-Jt<>pU&CV662DT($ROu8771SBYX>La)Yas^1b^S{kfErneCwNF@u{lYYbO zf#Ja#l9aXp>7o>^MRezl!~FfB!zimfgrt!S%?ZEh27yZ-8){D&5GmQ5X&{x=bXnev zRzNB0V}_=VB}Hj>Aqi(?`3GG_h(EM=u4&Ws42Nuu`oe!yK}hTEaDwNohv?-pvK?;lhQnCTV7< zgV9fwIJPACE@7HSQynCz$gH6p&rz|juW$rp52KX`6HcW=O*P?Rn<{23Mrws>XQ80m z3b=Vj>iXma`y1UlTb9763ae{Ql6q(t>NQ-Ixl;scY)L1srj~Cu87{8~^3_6E{i~_C zJTkNzRA{Z$o-~B%Jyyyb#RGq$%LP$c?g0(Hnl?8F?&q&|ihjh94Pe0O#V&Qkr&ln1 z^baJg2>WHqi+pTv#sZ}gOJ2f+I{KA39Th^$ynO9VB$4|p%!D7j9(gDMVw*tl#S`;U zhyMUx;iHO}B+D&TJ#C1)4<)JOqTF*>;>e=IEum@dhotQAWDCMq>vImW$tgU#eB2WW}>f{PWy{s$<@Z_q>f`-}w zC=jWjSYzoXFATB?U<&LVRgH-Z6fVDi73rkQaM6vR#AxU+niZOp%=0KxO|k$*tO;Rn z9XMFF$We+gXe6XfH&h38Zy1O!Zhh ztg6w^O-v;Q`$075JA4V{){!JtnQ#FV^;=IQf~uERk=0o&MYKk?zTb};3e#6`1BFS% z@-z%UG^1)!Qmz5Y#*hRi$|B7|Xv~2Ji>K@HB_?t|JOM?zJLo zmIIh^3^yX@j3*kwg=FyHDINt~g`<>?XR}7mzv8x=j~#Kaq6j=`5OakR9Lv78qWmkq?QmXflPwgd0R z!V*;5#2&;Q2-Ai6f&$Tqr55C%&04-z>c(941(mT%TuTm%49xgxF=osU%VL#H3fXHZ zM!JwZHB+I|$ABxw7ij1);h{ac68JE2qQi+~Oiw2DBPvuR0>1#nR<&^4X;kc!eLRG# zkKJ{?p!oLT^B2i=krZBSl-sa+D5LdTr?6pJvpUvPBTrK>rK6y#sB5pvxD_CPI~_Q1 z!{nd=MapMOgqq9I3?Jk$KC;xhT~`KtJ}t)Ak?ZMZxcFH~`njve2`C+OqSI=K=%AjS zX&}bFX`bwBAl|A4#?yO!WN}`QaHkH*<3^(ctc`=3w32E)^H$3aspbcoG`8Sx+=KOT zB9bCSAzI3nGy?S-328-ZB!U`wT_z;hlFZwH*T=UEtuR$3c{ot3(dxIC48-7tgh}(U z%`-r^8-+A#ZV!KFHJBd|!-XZWh&1PpWgNeS=LoU7N*$PU_xeN8UnhHfYf62bk(v%^z}Gv)K=F-;E+7Tk8uW<9H}H2 z%{=uEL=z-I%^D`qSw?{At+;1wbf{7n zh7>g!YU;Ay3y1l_6ns9E8jI+lB3zsN0pW9icZAZ`5JCkXzr*giX|mpaO1VL)lNd}s zH;@)pEr-)4<8NUi{{R8-;4^v_JM>Qx_|eu-f}|^?8voZ^`r^k$XGr>Ehk5HeQ|6dF zuz$)T945RGbNis!at+<2!>R=T01wPm=e!{}C{+`6UlCX{E>~ry6_L=z1hNIWakh7R zTebNiu-H&E7&j#b0NX(3aI9Esp{k`GRMl9p#B1QIw%;~cWDFI41akIlf=yoeUIf=X z*Nx3nhprwW^1`Jwv&}ugA!SzyW8VG#t|>*R6kfL^!J)sZSb?C(a3TTby$uhP=UaY; zHz)GpZI}gdMsIzSMVF=s(qs5k;BWHj{MI_{xnO{O$A?deL85RxT~ux}9a_~Tc!U8L zkgp+aRJPk4zfHJMJ=9>40)cAyrIgXru>x63Czv$2Dn}7HZrh5D`F(P{k`C*88fIf%WJ(xeP+76R+yR zl5+g1kIbG%HShwos+S6leMQHIYjH?!nJbgmP81l8MHVBHstfssmb#tf1X{*PHeCJu z(})@ftup6~P}7Oyvy94MmZ~ahcwc-m!?xhs_qp%Fw721!G*gCzxGLhJ#IQ60gSJiCcr=5!?{wdHnC0s6d|f z+kl{IKqA-UA-Svfi;1AFT*Lg&KH<>Tk1bGEG$t{skCknp-@t_L#Y=4WMk=kV_L$Rd zVviNC%-AGUF-c!6@;y9BN;fgx3n;K(i0#WTkr>mx?ChftmunUALky0gp9=G5y4bV% z^ymR6>)~y}2^8xm#f=0Q<{J#%L&AVN;E}xPOlQGE{{T-MZBUaGtf${cb1l`)g<+_( zR6Sy?BN*kMUvzx1BImeJZ^9Q0nlMVDvqhO6rlzu*pEn%Y>ZZ7Pk(VjRaCPPP(+eKv+d>eK%5Su!y|a@~OhB>lQUOWNNDT zN%q_HmnV_F{{Wb69&|d~u?tujVMp85P9O4JGRgHK`{u?ln6}(&<e~ zEz4^stL7@Z!*o<*ujN!7nK2O+EkaZ`pB!@H5x}+psZ2tlKpxTT_-V;82{I#%0ssV2 zSgMl?pBs`QN=p$EL=xL7)CG zoOJlbCuvyID;cEpFvU@ovB=}HwN)i#HwvRyhFkXdw;W1fj4`S%VA0>IY|~pogVfSg z%~ZLY2%)ZOO8DA8FilSr?mAel&A|tO;*=K;og4%Zfm!Hrs+cg`)k|Gl6&-ZgOUX4b zEWUJf$Yj`~{av=Vvz`pfvDhiKB#pF7amuPX%0(jUzCkL6)TlN#1NQLQw)|AbcnGGf zty@cnX6&;hpt=`yR&p#D!1lki3wGkiQ{W&{G^lF=kXhE5{{Wd&ovh6a#&rW*DU^$S z-MOYxG{q_lI--Z(j>^!>iPc8CB#su{3u?QTo$vJUt@QBWN*h%AQs*UR>~{ggYQ1|zE3Ct{)WMqAZoM=;Nc#Dw)`0BpBP+%DDTE=3; z@d`l>4VWdSTss%02WUXPS%zdkW$q7u;lVag`W-|Kv`3hNhcOfv^v<<^s=Z@?Tg#e~ z@yJG@mZBmpe}(VGmuP~YI%eHw6&(}<$1pV$Gmw%ji#sZKs=2+d@Z!SR0*Xr-BM?!KB>{+*<4|`d`{Dek-<5j%gjj zu!<3STVBz@nBs)_(Ek84U|KV8bS1R6hmS3KJVVNwu@N+@&KRLw$AiP5^J%A*P48oP zz#nnq7V)D!9vPs^G2^vQg5y|ecG*&{B}3S%Mx}fAvE`MCr)^x?1q9elOj2R0!E)3@z9?Lt32e;-L#>TuzO7`9;m^-;U@IMi@qIm_lMltnH#Xx1jW zyCnrFYYz{$KCS`x!@~Q1UyTX(V-zo_{Hy=aa`nweB|cK=)nAw8yW@joWN4;JN~R}I z_>Yeu&D=8iKi>SsP8qqDKDF**nv2PlHFYOGE~t!5>FDKoYHoqO>`s#PYfe4tV(Kbi5*o36uf_~T}I zB&LZ)#f7&J4fNE3--Zn~MHV{bnlb%fnQ5|Qbn>do@L}}v)5^o`kC#AP6K?(-B(+EF zDAMWKZw`t9`bhhlH6%oqRF7L+mr^ammy&Dn)M`0HAZrM2M>EgEZ@yvqcMHf}$#7 z7!$A-BT`MTbH*FDgvBUb#F{tVAj>s*!k+}p_?%KjmN5H8Ndkkv5ufasqtp=?ALS$+ zyA691U%Hm$PBdd?+SaK%C~4|vQYd;~gijSb5lN03WBj8ArV6oAMRF9CO%*gfyPZ9! zg|@cJxK|kBe+n?Wx=RDDtG_GaSdL`P_{M0=n5);~##})ony~1|)KdVO+eANP4#R?n zm`iQxNP*QvExNZ{m2IzM6^d%``HKQpP0|z>JG`>CJgaT#r6s@yJ4GrowR$csSySd( zl_{JAkau#UOMYXXxk-WNNt#g9X(3sN)?#?9@<&#Dygh@2mgRLVac`pBx>?gscb*zy z!Lbovoz_N-vs0x+jyvvAMIg4G0{U@M@I+EzzZE}M;`I=kO6n@6ilUNFDI|f)_taRa z(2Mec0wTQAqm2wXQx;k4D=KO#77_ftA~G=yK{G}Ne%ki85kAxbOBga~o_dNJe9;AC zR2DFxlAYAt-*MF2jiIMJ+xJ5rSP&W+)EOfM$zs873e6 z`kqRf(veCE%TQ3AhT!%F=Uy0;n4~1Znj3S@JxLY^l`#3Lu4y6)1a~89%>MR<+Kwkf zWGI@raBQx!mSLc%!{cv1%pgczp5SYH3-iUUit?VqE4<5((P7YF{$m*?sKcp3`A1FO zT7h$@?l|*p;%TttMJ8$UG}SXv9mR~~M)A4qN4xtu?(9>+Lrn=;&l`eT*;+Y+O9z%* zDIJUoexBS+%VxamgJIiF8CIey+^td=@83;RAPZ|;#cPd6vzvETpLY-rM{nNPi}ZEJDWqXSG5HB-)G%n(&o#VwM~!54kU@7}|WrMML7 zdJQh}W^GJ5O1NP$QatgQeAyoA35k@b@w;{$O8vPw)9AYqg?Aod-xGhN3TdaPj!5>K z5Cdv0q47Ly+8V0w060{fo7Bu#Bj@^T&4OZbVR)7h($r8^(=iVe%S`c-cKxMc_JPoj zR_iVfx1m50R%YzBy+Gquo6}CPboe;l@y+;^tT@99v7b|Dj3&bIh-f*Ty8ZX z#jG9~f5OZ0?kspAv%5vXPfZr7DrQ0BRqaQZ>Y>CbWM*b^UKVL?M$k{+!6COyQBUR! z(CLHbA@WnK@-nkgNc)X~vl-#gTK)%#)oor)(VTWtHxS1IR#HVNA}LA(Iuc!0%q?wi zU`e+Ww8T>mzce>=nxIr+`1lf-*)antQf=;p_S*g&M}7AXDtgIy8hg(8+!!2~d(P=2 zN~R=|Knte+=KjkLC%121DtW@13n!}>hrE)R5yXf{>~9cm{kgXr(@)sClQfE@FNX@) z{KY7-ln5`lgp{{o{{RvkcmhB)tG`GQ*G4lb<4}K7FyR|rrKxbNmffMXfILL=XH_I^ zaWopokIN2o%+jzX6`Kx>u@?n=l9u{(+K!6D`cm_eCQpS0V5t13uhT5pr?W;q%S-&8lof?w315TgYnSt%G_dlDJ{aV z5NR)%^9xksSR={|aiv8v)U+nYVn-V{Z?B5bgBVf**xo?f4uOE$ZS~v7hDvUW(C7k|*p_#v zg??I!BzGi6u$Al%tU+RR(~b97&0oHxBLdNO*0poAcP~>6EfKL<9+IS zYsy0UD8lqVqg5S7#!e-hBB`UxSaaQ>3c_mXm4%^A*0PhUH?u*nWH-5hLSZW0>|L^_Z3^x#}mWW4lcN0G$*K02&Sonzut~0V4_wJo=VonqsBL zBBHL1sg1~Lh~71@7Ivl11AZ`@^^4=n)H1R(Z49Pn!zvfczz zk1pm^riQuRCqU6i6alWWpAXjD+S{6{Tr*5?W7Kr;)JT!a!N-|3#)Xug{?6x@&?dZI zr!1j5)nc@h(?~vN7MiEakP@L{d@iYW3y*5v+@j1?5Ij`3q{`INM^a{~Xyi(dE?ALN zuHB*g+-q<+!rlU`S~E*e<<$61eAMtr)e+P{u_HJD?MGL+0NVUz#p)B$OIR>zo@J7s z6{KltRU?>tuIq3tNf)+&`!B}Sf>XAfO0<}vQy0b-9Jd5YyVxU0`y&BR1%QM1i*YDS znpmX)LG=zNG*xmxneXjj#^f8H_>a@al#vvbYk`Fb7A&~ixDOu*hGo6lek4( z_XMA(iQZ$znzL^hB7#hEY5dwoX#&JN)kxF;#ItS&_PGQbaK_mJlRRS?rd+>?G?C^I zBM8qs1>7#d&L0BYAFGZ&*d$i%oRCjlCUUKC!SmbHO&e}8F-MNz2YBSMKVLMYcxlzW zjSG}`;#X2)6448dJ10;dqW7)k`SRgp}1p8;x!@+u^|GroM;Q7u0C{9h7vS#1~Ikm*n4wVH{P@fo9nnl@shRvW>% z9^b2;aUyETaEg7-*r;i+#gGq|hL)NQ!R)t09va)8X$Kniy2%|z8%$}WH49~Um3Fyf zsRVWdUfi#AYW?j!W(-PfQ#01o{kbZ|ENHP=NBhkhivewT(*S{6eR`EcmP(?lpv#!8 zBv^e-W+PimG&E~V1IU1~3tX?+xi%b0aOy&YkSXR_SwSEgKwwJQ4>&hg_rCr!Gp2?I^Vi?6#bG^_k&mzrpeHZ{W<C;ZxH^Fzv0amr4~K#1^PyXJ zX}nMO-4$ECYUq@`E5|A8Fx8T~Ce}>w(pS$J^Qh!v#8cIcc0QV1*pA#5Sl;)T9kfj2 z0TV$jCLs*8@~VppT6rM>M{;C=jm7)x!wN6g;)+b;Yfcu(gA1uDk&+MJ#TRIiG}c__ ziyf5Zh2gX-iDFeX3KUg5o1Ca(v6WF^FYN=3CBhN~DN>;0#-Hh`8xO)LX>MV9Dwa}9 zUvBNJ1;@biN=Bk9$zIwF@nDD)O?&9EA+) zP^_z{BrzjH@#U7^jtihYc7s>@+5ix8d`JoI-~e#bc5=zmw(} zq*ZnWlu3r+>v6AbKK@60__Za*z#KkwHQiY5T#lcRum93$_3u$kxofBM)5*Wc%oOx2 zLV=>uR1gT)UO@Y(&=*So02k&ean4Enx=iu;RRDGL88apwT|&(asZQ@uV2tgzp5F6q z(49PaD&@!tN%NpB`-MuNOETkhc#Jq`h|gJx5RZyP&^iQ_U9`QsoA%YaKHXQH6Tm#bcBeCRx=S+|gTmA2v*-O2CD zm(v?+sY#j?F{~LXDw?vMtYS$#ju1I;$^#K{4->U=os^@wRUol^GaR6zsQFwxlQgcO zVq!xk;BG#T4k_RM4Z)`h49{i)LzU9+D)Mo$!fjr^O>_5u!6pTq1=ew%@A! zLz-zR9w?=j3MnMS)s9qT+^H@P9d0X!ywl=9QsFpsD)37*ihbuBNVI5Aylt;xz=&aJ zT!oT6%?i_cg#Zc%uvE-j5URl`C8oojX)z~^)1_SuJL0EJmI)n?a6E6v(vrLhro*Xh z?5d*mHGp*nw=-mR5!B{o`Mgi%Ka)c2X`xtY(7dIsw|nXU?cu?0PNve@gwR(yF1YGS zMiq}KQ&r+oR#Vp<^z8wG?y63kjk$Mj(iam+S#4Tz7}WY4ftVm@EAc!IvY!O0 zsFo^hUP#KuP(vXG?eVZbPc&~^mZjrqOh=YUNsnX$3@KrARh5&1&| z6}7b>w4NNeyl9QJrCT@-%3V`sjB1*Ss+qAuDp+~3!pkoAJ5=gO?`!ME+_`R^47nIn z)(1~RCL)I)$KMN@7}f>c9nSI|f+mQwZZH8B<%?T!pDOAHKe8EpL$q`8A zm`S;u6Jnr`3*U&6_~2=8a#iP84jn@#U06SwM=69!=gzJT{{T$|k#F3UUBl?*e=wa} zYTe4nq{?N=DNNNgnB*~q0#DQ3Z@Sue+>J*ZFN$R>n59-3m1%0Q+|5AvqQ^Xxw9P_5 zF0VS&Z&9aVu7v5vp1wegYRy|HgF)6Qm+LARQ$dL=^>}*)X4>IHe)XE&jkMyXF3^!A z;Z45Did5vzkm7YxV%0VBe4G-xRl`)L%vpm%v7dEy1$JwGR_8TrY&7kzUgT^sO*K6g z#9uH}*3j3jO*{oDqMKs?#diWMMwSPgPHfhkO>6Q?1d~dPAEh<)0RmPq4Am5M4~13RI@~^3WINXi0^yys?3?`tESDv!l&YWD9#m8tvh8o zM9Qesq_ZIkR{D}nyY}aXV&C+trq#j1qC?RP*BxFTB-m*&2S-S}=+)b61}4P!8V*?I zXc$dsTRA%_1}~KJ-5xS=2=HcEDB1|y$YmgHg;X00>vTM;cPJtzs^e=(*+-+&y;diV z)Ip2pH>blX@O)bl!-fviv#muOdwyB8WC}=ceMmZv5$44N;BksPu((=KL{*C%PbvzJ z<`vi-9x+!;f*36gB5WG?sJYai3-FaFCNVUuH~@$g9A;CN@i^)lJgF5NwGq5A$%cf8 ztGKfLi(KB?9y%bHD#Dvf@MbESy+h@0qCZpS!%~)fPBB44O7-;cn9<}_B~dnC+>9_$ zeRSZnFMWXC-IPOmhYPc|lGqPU`in*6!--(i%K>0rNoFBbg4fUkW)Yk{vc!-T|8 zg+EO*1|p2aMzPUH^ASc3w#&F!n}APyTie8{%v%(w+PGB#G_c4SR=)|vDn=)<=qgp{ z>MLU*q>FO4r4F~cf%G0FxXfEA+g57PVMhv^h-5n2$fb&v(yY0)G;x&G7v55D+d;}R znInxnY@7pSC-V16bFLpYEn8EDz*$(Ql4_!fp)DY}_l~*)$CaEh5j4|TbMZQGsF<%# zvDw~I(L|6a^V&Z&HNETGL2KAwmqu*S<4i8e&~{R%C}8;BRj7{`%lL$tMmdJGHMn*m zgvu6JB#uHsQQ{9{abh$&aW&o3P7OF2r8Z4C+O=^NZ9P5D89%PsPNxLVSS2s@yr8Gd zczslAlvuPxDDyxEatT462$CxWJB{_*Z>NdwGlq{Evl)A+;kKk! zbeA^Kky7{s@T{@Qv!gU@P^$(XWa@P7@#PVjHcUvTov?Rl2DraSGfXs-HBK8*{*zN3 zML4p8H$=Z`=i0XB{{WjZa0(b!lb2i!N=+fLo{wiLipgcC!KIOxXklTqc+o}2w~A4m zvXP2~CUYyfQNS8?rs)P|TrQTLuMYWUrc+NkO319!NOS_{wzt2tjX9pNuLVs!jG_HM zZ82ARdg=}#hkTt36w)jUCg_%?H{8IJ+B^3a*NPd>t%;3QrSAQ~{u&K421m~rb{Q2M zxGhXlQG+7ASqKP6ECTyQym+}6%p7DB{GI1ibjuIM31Wzu%f$XEZ<3B7;g4K7N`A_+uKCOHjc zazAxn<9GF*pW9r%SIeiFAgF09 z_9V%s?;j3G?l@-(2rz*d<3`&h^y{ZmM#))}>1!k^8H}lGy|lR}zYAZwQg#|%)v99w zMk@j7mq?`%J7j!3x*xMphQ#d_ISic0yk2*v!w@LMYhzciMfX;Ulo6o<+sN!bJXf0L z!I7mqYW6lLfK`B_iwCE!p3OAz!ImLf(w&vYK+Ar#v?Z zt;6awCSRk*HZIwqcml-FxRIs*06uEtHMj}`RXD3g6r2-7ulbYd6tr={SJTWh5O|zT z9URJ7TKk9ZXf(0o$;=%|omkQ@$|5mN6(zcP(|Q^ir>W@<4S2x`6&l8F#fVZnXaf(= zk2RV+3{5iagLn~76xjo!u}2%%bn^@I6&6txQR=Q&?45NNzYGo9j?+nzZa8eEejn3b zn26y>I(3H8TXTMj1!4#`0Pel}@s+%?Hkk9RwQdIr%l>V;SytkVWE?6=$fWaRs5H)<1~*O;y%Hm9n|V(O!{JEV7J=g?aM1c^)`JI^V#T`Y&O`?p-ZrH6LlG zT4)X%DL+?{Iwu`xl9>|Mw31UWo8~k|fqppPFsiqdn6^IzprV0*}K=4yn^t%8w z!)P@$_-!hzX2f6YUrT-5dBWzIlS~Al9hI7+F7#@7;S}9F!4NP4nlXmc?YXyacGo`M z7rx`6KXLcchMPb;DZ-mCbeJSQZb!kX8cRm!l0E^ z(#B#!nh+yE2-lWjO8$}e(=H+g$}9N;3Z=mFzG0sPpn)jo`A91wjyU7m8KxkBiUI6< z=s5Ojtw>HYN;2{irC}71^~E+1OOo&!=___Z_|6*PW{|)nkkMAEqL{~fuxobHi?=;8 z`s1VKDGu@^mJ*}D{EZY$sYjOTYRpncPLsX8_l`CaUr}pdD`L>zlXd0)4b6XDn|_>7zB5@}5M*Fq#Q)tRD-h zr2lfKYo|Z*Kk1EBV!&B-3kX9u)01PwC|~TqwCm z1*1p(DUE0;8KwlCJ>#w2BxO4WXukktP1SH=p)#- z4AxbTzM39uzIAirKH9Hxgz%?W@@GzQbn>b){uJAY2~8C(Bt-3df;L7E=fdl^oz($k zdYUn`LI9m0(=@#?>4qO!H9*SPbu~ndx;e_k;aIiFRbX`heOydmc|XPRr73B(pR{`g zaD%704>K^LhMJ63#k8zc(No4$F|%zY0Ve0S!-`wJaEK}+)YAspDa0gu1!br7_0wFp zJ4+@VJ})q2W&UpILs7va*eP8mQOYwV6%`&{!VzE( zJDDgboqRhe@oK#G+(W(wZyjwBdn9UkJVuB#ug z_B^n^Kg6ogv^bEOO|D$&^Ps*PgVw`w4LPO5=@^G94T%we2>2a%Y@3N2X%t0qlLp8& z25Ncowi8=8KQFOpD1_UC_cvSHhcq-e~Nt49qPVoKSzn9veH@c8jV$V!IUtu?F>7*IW(utvj& z^DH7%#i%J{6#|;H@A+dAh6ydNxkb;GB)4byJne|SK2iP$CnpQ zDwDNn+Hoe5RM}usPc-!TWK`8oe8-+C0WrJ#?PQect?j0quD7^T{o^3d3dLE2<3BY{ z^;kr{T|4=k5+K4$oz@^8!@npL^z1WE_l+$(L{}VjrKX+|(6kiHs?|{k6z+fmcQ|u< z5pl%gfDq?meBkW}iE0$1K(` zj6A7lK~a?J;F7y8Vib%J`7$q)YaJLVWExx^=Z?910%j>PSa2OG7|~4YoESb~b)uIL zj)`PGYZ_P(GHuWh%ERdGW5ax|`}n4PX}g;hDH|~Ish*i|TqcJXgA%EzHPx6^ej)OH zR?yGq;j~I*J8Ui%Fb(`T?sarYPeBx2V9Jsg8)m=%)GnUAF#4Q3r}+|=X`%Z?A4ZTa1vKm4A!#6*})@fmY+9e;T9Q`_;ao^sgDiA&bzOM%@_HcX4#K&KoJVi`REvsTxL$3BZ-$DoJ`d2yXh@e>|<+ zXKp^zTTb%4l)#T*si*NL^%+A^< zWoj`a0L=y)AZ7r3UzR(SYsP)1s5hPYnD|nHPsJnELZkv39JL$9G?6gp3{AngA@$VX zj2+IjJwDS;r+MxYc6)_5L-?h7t(2?PQ02)919@yUw-Tb)BtE>Nw>sCa+G)h^d*gui z3YPx>inpsOI&^AiGTl1X1G-2s)?LE(x%d5pl>Wt9_4`dcjqbYW9>GR~(|4@jSN&8K z8J{@Mh2b4Gp?9XE6qIr$W-(S2gB>w;_hO9O&63~ht=H9ecNJ}*&EenB|(N$LsQp0y@FHiL;SjeqKqtM1=z3Yw7KuXTixACmQ|#a z=R&I++f=8-;PxNFmUx$|7;!V_9=+w*lAWAWhOMWLVs>{0B__oCM-nG>5H_ICon2Y8 z8l^4(Jdfc-bE;p6kExEG)g~X7^M+H-)L4amO+7F2=+d%C=@Aj)X&N`beF;815@p+y zW~n74M_HhLcf9YkQ>8&tdMOn@;+yLpk~OF_*=4Lj0q~ohqp&{r)59O^HHR7Ynj#z9 zcN;yzpJV)5{aDshi5CmX)QwKjr18UphVvQaNbUwb>$$D6P@(HqMzCSRdzfneTl&zW#0X~^EIm*|IeCcuHGhc@o$Ssn-4X~gd>$l^VMpyoft1J)%JY3AdZesjFa z5A}YLKxI2e*&L&Lqh~lzwAIe>-1LuNrz{WgJoSZ&MdmImm)2df)$SMtAh?WP#{I^e zan01TIAb1WsGZ@s>h=mlSAHm-v2ivOm05=c0LswI^0*x&Lu-U8cH%R+wqWc&(@M_s+^FLo z!AY!J@h|n0NhL$YU6rE>NRY>r@ZRh^K^$Dx>sg)$+G#rT+ku82!BH?D#ADVSbtPz< zHDHA_CuUus02_q_*m!Hoy}Gt%f%cl)d&hJ*k6@@Uejz@qu_}Wb<_r|LU^k`#LKra} z&YW!SZH#O_(@wR$cZm@r*eT|V*Pp7&S*xmP^F9?FL~bZnXs}uoJ6a`TG#dS`Z9AW0 z4hcTfP95yKP>CMFP_a+MJJzBGN%QU<<~T7n%nE^6r+~R$C`Ren#>4G2iOuD_P>CMF zM_cgN>o-}t*P1%RCV$0a%uj;R;gvLR1uQhH14&a+8CykQcLDWVflc_!T4A>Pu@l!q zUCqp#xKjJh9aL_;dF9z>$~Y^^Tlr-?)KV=zim}zh9a`yb`=cHFI7_);qUByxW4w={ zcG1^9>etp@x^YpiWqro%P zH3dG@mMA}z(YnS81_5p~?s&rYYRs8~x1`gb+B?NB~>ThM!LT#@cZ*}a3Fny+yuXyf`5i+-|zgl=$f$4gKhAqKOlVBKo-s0x_ zmtMn^JE>%|h(6O*PV-$SVIIL*secrYTgE?kKH%}Z0Ns-kt_Y38@C={RBR6fE@T z@dfn-iop&e)E>HFm~f`8nvSmrI3)r!w1Ec3+!R>c*d7;OZtc5r8$rjejO=rlUQD>K z2bT{@GW5Q?DDl^g@lLhFNew#(j&_2Q1(MI8Q4k~!{2*TLl4Q0|tqE=ORy2(+f#_;B zVfEby@=BO!y0=2o6_z?VD&U4^GBW5zlJ_TFd8YSsTEw(*>lE{uyGRlp6Xa->X3t(e ztZJfPaqBfzZ$0No_6lj6@f!7^ zLsC{AsM7++YVW~l4S?3d>!&V_%dj89eWs{)qV$|pJ%XR`kHlNnU3`;L*L4z;5r88% zl{O29S${}?8|?o8TaB-Ca`gWI3HF+>-mBgudj&|V{6xK9(^0(|=h|qHu@WG`u>FpJ ziw&VZ9r*fpV$Xt4w9^N8E=idl!BA)XL%m_oQyVu@X<Wa8Cs#hDlb?KIE!j_jSI*ePw7ePnvd%vo}yFj4h-nu@-R zsCBEuXpl^VS+Y%=( z@ecKnl(1H>Sn5BVN#-o|KP5(No4wI(me%KsTirV%XG!*&W!>Ys(gcrSp+o(;y=hQk zjaL_0>eYoLHO!4gMpo|-Z2?U?@dx&H%ox&rrj;i+xhdK`lpM$Fht@`Eu9_^z)#>pS ziZ}fn_;nr1wzecC?Wb-jb9L+hoicpsrZHERVoRE;pJb%o=l!>E-UgQdczx)W|u zd#zxp@Ska`o#nk76g`xd%$}xwN@Ct);=M^}jHQ)>(9$6w4R5tQym^h;vqr?9Z6{Xo z-Y7v>k1DcH!rwCIZ0(l%lZ$2?Vey*WD;}PTjBG?DDlptVYzP(sNhj;%d)g(dO*q<8 zHjkYP_bTznT6136`3nElFTaR>CsdgmAx2eK3`}l{p=Kb5E-7j(2yI2Te-2~*bNn{@vGjq)`^JzAuP5n4$|yrKq;8Ez~*=QM1e1Tuo+>qd=p1RjzJ=hUrm+Ob z+e=%(sP_Fluw8Gu6r74L^yUj4nG}(IbsikIdEu%pxm5}@xO}w~^vt9roybrxU;**t zL1t;fncGhC;L}G&lM$nJ`uEVr>e-r~Is=x7lBK=vSC#Wf&uG!k6XNJ?tq%3OLn;V*oFlKtH5*3aSj-J}sQF3e3@u zS4)lKc%%H*Cy3UPUEPo$paIwcpcdfP+$E$0frSEYbvR0i#M1^Jg2gm-F4W6-(1qH* zAblKlO9No0QlAMmlNQ60jmG<&u5JxHN>$G{j;rE7+8iXl1`}2A&+V4q;ny5-C%JQ^_Sh z6(ftXRZ^&7?f0$Y@Z}1in%a}HpC_O$W|Dn{8Nw-jHXXp&a)Cr_t(4R4HXR*AlxqyW z;FNC>-uBq~+x|?fuKHgmht&J`^SB1&u5MkcQ4PYxL zV|Cg=zx+##Tss0yS(eP>NG!#aE3g{MO6r)(Q_od1NeYh79OMQ1)qx*R6g2QsNEC_7 ze;70~t`Ly<6@@OdQ_2vaumN5%{CJs0MHwOqq`dfiHMKSItYyTCu??2*wCiqDy&z*s zOKDK*sCjP$dTcurgvL~)9(2-Ji~f+G52KIkoM{@{AksGmr>Ul@#vI3}k(w}?+$q_o z*T-BlNy2Gahv4-UG?n&~L0UYOv~Meo$Xj>kZZH6;9%N$h+5t`=^&i;3Z<<|$@$+LXuxiTPHyxQ-1o)6~Wy zJ8PJ zcaV0{_@?|@2#_NAkZyOGAialnVfXgt(%{6?PQ+4`viiYGBE>)?Sdi|xUch$aYI14t z+z71D-~_cCRWxB0D$=0)qux!szh^b9Ra{R^4OKWK3yNh}V2IPeWRiSAshL9v#AWop zo)+SLbgVXJleoPFJe9OGQL{+|Ej*Ah+Df5oC}5*THum#qQHp8A14talhDi-^Wh9FL zNFUM15~3=hAX1ks;cT+ax-xvqSNA0Gw6UJ!>gSY6tpNtIV>lXZ-KEt@D|6k3oU3PS zR?2E76N1NGG?BZ6FjK3E7=~Mt+8?KHE~Sx8B{-2uEN3jwM>Mqz>*Yr3h{z3?5hq6Ev{OJu;UyVpyP*H6&P66zcOvp@0)KtS&r3*heB!*b(!*=UIB=F zg*89S$s3dAL>ug>J^hyBt+}Z)NZxNsqo$VFeirfNcw&m9sOqRfR8q@NaUf(Q3layjUNY(uut69aeU}PIP&+Es`YoTZ zF0Ezf>5h4zr>U#Q=_jTccM;MYLOORTE5pCUZQc|cskt8SXwx#YU6Y#I`$6_pg<*1w z_WQN{@y|t8cd0)~n8!x*bq*nftk}m+vHHIvgArvWY6*!X(^XpbWw*M=Mi%6Wl4s)K zuNU3VRYzH-N~?EvU`;10GE_C$L`6KHJtiFZtpvy}H!$~?=>Z7i$$AwvR5C&Z6?(`& zMBzoYsB52PtS!UVNTN%DM#mA$6?0)(X$bP*t);_Ot;d9aEFRxj;U{~EqvnAr6oeRJ z99s~qr5jd2SrG{Fc3TUNh~v7Z~+A~4U)vwWlfN|kaqTHbR5~hQvyi_Qnx;yHEp5nfdI-vZbUKhmyo~!p zNn7onubH9#Ah+nluw_?)eGl(xh2CXnw}+XuKR$wBi|)}_?zF7&7^{81$?gvq%zRQJTmNH zRl+MQoz&{yKMpUND@ZZdNf~fy#IFv4e7g%@PkigI!12)KZ%sDi6s!EZ3_!*9NEP=0 zKFD5GCmOU;NvQ|(xlt5G86LsA1IKlUtr3k2I7SvGrKe?>MK9S5!v6rcJ74JI1;aI{ zG-kS6(gw$%rNnbo%{E(K(oj-U29A6}Q2NBL`>_w+e}#s;ExNo3!8>Tm%E?MTEtF<6 z$5L?qn&8Tmn0!@PvS_2ja7rq45z=9F%7!#M27wpAcPHySAYp|*tPg~3>*uP3H%}(n z0RI3N4yvylVuKOQIhI^w6|8!^Mt#+l^;5AeBNi*KhMvv~nE|8(je>#~C2Ay-iLBXg z1*e*y<*Ja0XOGX1O*ZTnC+P#5TFEs;Vk;V85nQ=lwS8bKp>wU~HwVZ$|IDi$}D z=aU(xUoP{^vawxlqg!vo!UX}p03hOFBk1rS^38eQ|GI6HM>rpK* zivIv9Sd&|8J*uLQ-q2ds?euX*Uva5)n>4r61}G$!7^y1ho@iLWOfk+O7rbSx#QX=3 z4K-nf6^c+})HJS?)%20xlAf-aoxuPt*bNT1?aCohPAG8{UAl-+Rmmi30vTLJRA>lQ z;-&{pGVv!GRpnYS9u=e8 zjciD#tUnG|O*oDlq^zwYCC!G@srt_}NEK$&sKq65%q|zj8m>$2yTfg7p#XjSs9e*H zCmI;~SCeMN@!VqzrG1k@LtTq9Aia=0f78S{g}_PyJOHXdRliLwv|zZh2LVDKP_oSg zd47_Ls+A^S%~L4}xU8fqmegLvE}Thj>?;a-<)nng2e^hC98qCZO51-bL|We{cumuN4(^Qe_HJWc<4xBKX2QMo8YR zpl!O9{{TgazdMdm*8)sd+Y%z7R^SS?QqV@M2FG3MhTiYHU`W%RLz7!lW~@K(>ByBe z5_JKn>P%BG!>XzzW&_GtYo`Lh3ya^8{{96xlmXN7G&tN<2Gp{waQV^v^}NC!o@M%p z00|a3K`ipZdy_#ru>k!XD&5q6(1X$Q6nlJhsR|#``5K^dQo4`>5I-$lRc`@rotsh# z`Z+43MMaK}5v0~50xe9$02W3YQ3Ze@yBVrp*+S{MY(EXq}Y{ERCXVvQ{m0(fla(c3Lhc_5hvSy$jBF6ZY(&KlqBI<U$ zHmO!BbiUTTt~t4ZTUvHfl7@{c4kHYMYRIy0zK7ihLEnuNP8f=LOgf&YG3Cl8x01{z zF`s!|77{=|She`dmO@FZDFI3Xh8i5LSB}d{=_GV@KQB`CTY%iL7)|V00lVn%;aj%= zV@C~I6&;!QYxh~#U)gP zfHot6Z*T#qC$~J%F*R3IkU*mclxD*rInF91CX%pW&relr6;%14Y;>?Y_<``EM@=ub z(+3Iz^IaV#S;W^AO2zq_gCH=>;O|$lIud+9;gTe#D6zs4sjS#81yzdS4M~TOJ=<(> zl~W*Q18s$`uZJ5dgG$pHDbftRjbN)JGt(M+ygUj?kfG6+zP}z@P&HDj%heh23@4}k zH_kW}bl83|gw&bo@d_3(%>?n(OyWgku~Tp@#CFLGacNe=R=RYdlr1|!!{0}*)Bgaf ztgY$?EY#$lrBl<>^%jzl)8m+ZUhg$12w$apVJG6rMB@Vaw}<@Tj?!)r(_Bu^_^HFvh5 z3vD;$RXYV$T}376=G?obRA-b9*FMX5aCQv_~Q_#>$Ea;}lqKY$r*}%Yh95gNr!(jDMbEcw#t~LD-Gs1VS*0scBx3}BF zLjX})mExe@qK;fsG1k$E30P&Xc=aP_R*}ztqmF_CW|=7j(4Wzqp@?EWMNE<Z7^Ue47^-%&w{N$BJ^M2AeqS>}oy$&}cL!g{ zSO3>2zlgpwB>g4JRIx3#M# z{{YD;;@Y-nv3p%0?Ty*V!WkV}BjJukho;ZComol}uk5mO-IEqq6*M z%V-r-M;oENE{`+e&}Q7<9JIMc3W+K3stAK6Mmbj*Rq`M|y8?f^P1t>rc04A&zR`kl zKMGxAW?WS86lnT~)EZ8nV3e&-OAF@ALYZNp!zl_aJ{tzoh!s<^rL^%U@8J^`>bP=0 zgO6PaAG<}XdZJc#4vu>0m`7iTW6@ONn8jOHS5^k7sjI6uXKmzPUuCo$6QQ)BAS6H( z6;rBo>QRzv4IOetS|pR+K1fsG2`t_Io;Xp{R9We#e6c+bksPx?eCX0DX;|E7RH!4` zJ-pMpjcGVj)?>mFohGD=GRG_}P^jfkcv@4a>@UXIT#CDigGzjInm<04qFB~A=wvp~ z2HQT?H#WJk8gV#T6H7`46$-XkDW#&S0?p*Z62_PJnAI!Tan`}pjW+k)g;+LX%k-7$ zN0>2u2+M%QOtQWeRP8+SNlMP{8_PR^W=B@y2F~2BjxXSPuKJcH}rALhts<;xWsZ5I* zB?77{+e71Tqk{O2loirye9$cPcy%GE62}-VB4;;w{GHgH9v^g#mp*!=QpV z3LVWgM2rJl?3*pX@Zy#fOig**FsIxiHirnowt%u4#c4PFmG=$5k2Ml$vWiyL85Ls< zF61tyS~1)1@25Nkcx*K1gOTJ5(h&l!s7@4Ox@(Q536EkJjCCGPBZyJYhT(>sT)Q;zk`IN7hVS3E3h!E$ z!0V$c2Rvl;P_vyUpq@HPhW#vQ0g|#Ny~rZQ{{Rid0mK%_gv~3sbu-mP?z<6+d{&)d zi0y(FDy~Vk=|CEv0mG!C6DEnngsTme3R&o#9%qObhz-$})tcm9_V$fArrD>Kpi@{V z;76iqmgVMDX%+2j?{yZp#e8{qgGt*)plS+Jm?oO+86*MC{5{j9zOFu#BARp&vu!9k zc~whI4nI{q?-lDpFOjqq{{TjWTxrDDK-0F-1k$hPut;hHrs<`rPnNump}Sp=uwRTR zr#Mp7DF8|6s|)-y&|*20tzKMWS}JNfUnz72U2y`({sfC#flcm62t@6ll?iu9Yg+uM z!}{_uQuOaBMHnE>j?y!-u{xS+hd*n^+#%hCAI*{d@61qxI#!!ho-^__Ky`Jfzc?0f z7M`}Zat0fhZEU^38&KpeA^HD<(CDe5rA`RM5>)nW2#8YOT^Q?qkwb-6n8$&zZWiA>T| z$>qmVkvWl`M^dErQg8Kf^(Puil>#ab8!|Ms#YhtQ>8_vSAGek$!m3r`6e!a}C`xxm z3-6-?e-bQ5-Na<$OZ8z+*mM#>i%=JR@U-Ds5BRJ|x6#iXm2`^A)lyL625873x5UW4 zH+_fh5aWl1H+QPw0p`eSAxBVJ4nr_{A@B=3~byF}X0xT8Ws< zwJRRj$r~0wF55?Y+LMOY z5G~0dYipklHiVd`RH>vph+7)0A)4_=54aQ?ljb$`__rJeneQ=*3De}$JDPV-^mUm` zp?icnp8n1${t88;ca$XKxc(u7;CPiaJfAHFH9U0G?6%&~N4iw^fw*D2h{7a^;YLYz z5=8bH19=QgGBWhePuZ+ z@ytk7V15_j-O2-q(smuROKWhXI1~&K#;voZok_woeov*sa~&e)6~}2Kr_5L^)-hBW zE{^dl9YO9?Y8z3fBMbb!c8--J?Wt!j%#)cm66fC@-&`n^dV}=&QPRO(nzFS)$2xI} zw3PJqXWp9(pF&`$+j0QEy2rn64KghGH%WzHu|O^2$Xv8u&k3Q^IA#n*vX)w=!|CbP zSg7eKh^P!wMHEOu+6w9j*NNF+7Zo)7w*)o^RTi8UuAVlntdJI`fn-EkR9rb0BToQ( zaMek|i&8PBB+E54b@_)DAcz`z>S$TL+pNr?Pu3jr#dC#UyW>N5L9o0_0mZP$@yJ?+ zo~Eukn7}LVh^kQ>fvxmEUkkG(1t7&P%Rxy1owRj&yN1hD@L^Qb8R{yegA>D=nFDX9 zh#zp90NcX@@Uh@`FJBru%mFmN^iNSf6H}U!sxugTazfF#+q4P_I}d>&cpcv|JI4IJ zW`x_DZdS{`<9vmG|Ii`-0EpdigCo$>JgvGq>^i++Z8kGX@%wfAT5=2ABrHgs8%5~H1>3%+~wDJkljSF27 z=%@AOuB$xfKRXZU)*nBWOARO~RgYE1RQ$CuBS@G1-eIDTbX|^x`GxRAB_|qNV`5!0 zMgY;c&pl?rvP~bB@I_sijXL3(a{{746&@W=5epn@i}oUqT|2Swdy~Q&TNOTf6U6k< z+qccyryNzlbWuvgGafCOT6{+pkz}iu@=H)oj4Vm|J6H|~+hGljDZo%#;pI3=lyT!t z@ZxeogvAjybcnQooh~G6@xTP(TWvrlDhw4rF;xUg{`*H8ww}wK2iMIiYtuB}hu2j@ z<&~;!P%fuIv#{gpY#L|2!YOO~`3*GQdpDmoG^^(p-MeyF-{HjF*yyK2go!5_6Dsky z%s703AdU*kK^o4q?Q-f109YM&Sa@-O#*<5X@}W$%HD53CH7^&R6&afe}N zI1pkfrx)TLb!FMFs15Sei$zc=Wpz_hwCKnh`)0W$8-sIkK?o+8OB8Ky@DpS47U!aT#1fC(k2X(b`dY!=Ke2r)_6cw3rL!n}|slQ_*SB-GOR z-=UQx5=SgT=X#U*a-z2b)`sqlOP6HF@m#-(R6MOd3s($PftK;rHB~;-WBw2c7V);85m4d5i zEvpZ@{BkOyoN~N~^_A2UNqxy2w9y~&68F>U2cA-E$ihboi;C3k?_TX3T{6niMOgBhoX-=%9YEF}Hj1bPQ{t+1s*J3s*x>2qVDCfradmAGQD z&ib-Np3VMo}OK&V)6;1u53tPRopkqw6fPqkQ{NS`pw2~xKeKidr{*G*nDTS=+ zniJrzsq&|C zRVsIXh$#lw@CS~xjVXalTsjn@X*n%T;%1N=G+}IYy|e?4QgUmCT#9;(R<)JG5|%2w)sM+kZvIsAs`n&_%XdEzIP%pA!jd$QrP8Abz-zNUQp(j8 zF#iC(`JST+nt1Q-7_ea~uiP)hjyw>vJs&zVwX`lIb)S_bYH}tkPmf^`R-s0ycV@Wm zs;0zW!%it~={jUp9J5kfiWe}94w3LWQB~$%515vfsfg8!?;!gJ8cL0AKy0Ber9v9f zO!c^8n4%&HratpFmayII@5V0HQZTDpq!URVvP~=G$*8F*#F0}~R7hlw!}Kp(C>wzG z6Ux}6YSmu6R5zq-6i~2=D!FOuUKtEgMD6ntskQ8++vwMa${;8TA|S-ki-$7R<=m^5 z>agO}b+q)f)iiTbx!h-1*J}@Du1Miij3vTB5-8cHmeN5vc2q_o&!q z9vhqMA$&g&ig?v%a|)19w25#QR#WeR{{RvkkMkUj%)Nc%M3(2(K0tixPRn!lbB6nu zpgb^>v0h}IzEl?V{{W|W=0i#;@U@mqq_TXNcT#1b8#ajKKjE+&TgQSNqcTI&J7^!C zWv<(*BLPJ{{?6T`#2&7gT+K`qXV2WNlIEQDt*aMjnDGxZa~xq z(EDw|mLDXZsx*DG0Cd!>CjvPw@c1h6d9iAWX{lC;tHT$hrdd#JQZ-}ll0Ceut_92r z^H$}*xXm0KQ!(JU#wUU13VdD!jM7O*PE~_N8S>4M7yMUkZ`%A1A*H1xQPP$S9;#9L zZhES0cNR0$HBX(3HB8j3wha%JPJymHn}GWG8Q%2xk>&HDw&bWKw+ZR_3jfg{Uy0=m zR5>pT#36#wRM+9~3$bM<&L=^y_<09zAyThD%|9xfcims)SoDgdY!M}zd3>;BS!GZ_ z?{E$$%ajjQVPOpQ)N_)vqByuxqFS(lhr`l$n zQ4vh|ULuiI$5T6nD*#4Q-I+zKFYV*1YY49;&;~Ui#V7Lg_d-bMBu&E2c@q4!CRjBA zAg+q*D>;|t-Pdp+0kmi@@H}!;RV0H#6=ge8%M{O4L&ywMJO!1z8(fa|w~rEn4_zz^ zBN~-F(h3-*T9%e=u(U7K#OWT7-3t zx)ouY^rY+vJik$XsKh^B$NnS5XB*qq9lfBY2kL6rbN>r4}cAoD#E z&eY7YGRS9XB#OgAqr=(>9J)cO;%g2kJdk3zT~mIEB9V+r2A9~&az4IYDUfNUeZsNh zn5dPZko)KzM~1qR57v3)pqaw7>dh-M)*!8j(5y^K5j52$h+Vdbfp3nyZD=B{+k~7c zj~AVUD9psHQv?7Ls4a3e_VZygP92j@8D9~kp~S`^Dl;V1Qak}}2zIECQhttAXfYLL z)eZwf9yOY$tEh&qtKNWb@=*K4Ze6}3wYb|&goqV&zo^nWmZ55K3W?%fv6$1%R$y!y z$k*=Ukx3As7EN%1Qw2>?i2|cIRyV%u0sMLBr)Hug)yEY|>N!HZA~#>4GaG62>&uwa zUc?!x*oxFJZ_$xrQZe4=TiV{s^GS)un^MfpJLJ4TrV(9-M_!atOIa+lR228Nm}3?U zHNKX&JmO(;YV4d1Ibt{@)8P+QOIm6LGk$_c79#gL?eFa6NvAYng;`hOlM0MOHyI}R zd`RKtRn<<{{{T77@K{{R=}DEE6?(`1wV_sG={;uviVIBV6)vM{Nrs%YgpBW<0_TKb)I zzaWXq|heI^c`|)oZqG58%ZhL(kV@aBH140)~zn0>e?+i-mg)JjR zP?OZUivVF}3u9~CsN#FXs5WAhS%Kb(rp!&MD03B3L>UCqyoFC~Q@y^9UA$5&ZVf7m zO5(G(oD677sgdQAQVNYPf28qCLXbQ$uF|P~Tq#1}4|Jc1vHGvecS4>qPPuwf1h|kg z1QiII?gqOhxC4}RI8_3OCmbnJ^IN8l0C#zdZJ>)E4KMWZuqn+(lXKUm9bJmV=-Vgq zT(I#mi8imo`kp%k#8WC!7|?H&D}_!!i%Jg0nkmKDT%E|m-%lTTpb{x73h`0p=%!V| zXXq9!nDI2U*fw)~a*Yv7yTSa1N@KM~q?SSe_;4AUyrkU#4h1pqsRwu3N|;e2?K45{ zcv?!F$$(;Xusm=^(1(rofR zBU`r(k82`Oh}998jZ~HghD?VF_IP50H*O_9bu*-SpWlxQt;4@dQhs7QPFa~_iB&d} zunTH?am&<5G|ifiPTEw(hb}pVW_l{vcSDHJH6(SC8z5Dk@~`*@8;6e&n(s6nE= zh-JmgQptphp;1vRvQ#{fwZlUpJ9{4hwmdfroM@%i^a!PvXsjmy%e0>@X=!NSjx|L# z03v`*zK+A*izS?GbgRt$Q z(4`?^Nx+SjYh5GiJx5b8T70XY3|NGVO&twHwRXIb`DjBBe%7pa4))Y?HO%tg$*)^~ zY1<5?;;5&pD|U!9n}U)rq3jO?IaX|! zL=%kzb8MMb>Nrx1JyBMSUjTwSxhm!<9w3{6WJmJCT-xD5Hy7n?ib7SwuIMBRlbWky zTw@QTtwm~z*)aHNfg1bM2#()j7P$D^nrt7qaHk(w*m%LkWe|C%RE3>yF z-S(6%BY>$3aucbC4_$x%(jec8O3h8uOctoO`Z=${>7h_>W)(6q8u-{>kcVdL*K&M~ zO*{Nz)DE#!osz2QMiD+<~GKm!_u;?Qj6;?IT zRWG0&&&KD3*0yT6Q6^w}==$dA3^pP)bX9)VV)dBjKZxTPtxT1bm96H~RMcFtV{_kK zJ)RsDvdU1H0tE%GUs}wQjVLhKmZpi{ZsX=1HMlG+d9?s3DBDg{kh!L-W+!#683S95 zZLiVIRrU(Yw9SN~#T)M1C!WJV8+owP+kQ}^8n7k_tP~g$$x{fDBOd9DuJz3AbhJ)!G+5e61=d(68SRw*FHiq)a%5hMxR(D3@S!BH80DWiI0>%R#X~Y zh138n2e5NM6Hh)96swafLswOYM)NH_H11)NM`B54B}IaQb@p>w^wo=Cnr5h^rlx{4 zXqp)$qz?+urq^b=y@=3q=@My`h#+yJ$Dead-_`6R7^aP<^QkCdj-rl0JekrkLACA$ z$+wRKc9z7bq|lDy@4^on2Q!9aubV626&Z=XXAX+0k_Ca7E6GkPg+!Z(B$8N>ei>WZ zfU~4hE6bfo8jT5^OUSt+5v0o1{X56g6R5>0lD`+h9z!&=YqfWs;SlXZ_JxhR-rPZ! zUbqT_sen1-OD?U@LUb9CK-W+@X^v#7%s!tJr`u0gJO-YoBXrvH`9ogUzqf|A*J*TN zMVAbzvxuPgG2rvV4FuC86lNg+?{M0FTvUZmrBDbJf}aVJyBUFHr&&a1F&q;q8_Of< zZ*GT{DvDvm$-t5d@akN+N#h9#+-1hF)62^G{CgZwFw{s z;I73{+-u*IQssYvXSL&o*(bot2*sr$}CTX-JS#)5MU{ zZMzj|N!kIwZKIkdyhuKj_f-m2(V5aFMcgV_l_5dc!K?+l^Fs=0NjqsRfJZaQionpy zB$Pzal~Zkiw(DvSvyVD4nyX5aPH|9HQAdbkl2dMi6MBdx1%1*6qTtx;#)%Z_u*RWK zV+v|!cxWSPTIE&pmhQKr$$1O#lAl=ZdY$>o9ZvmHU!qf zgi{__YL7lzcp>?SzGrhZY6F*%5FdE^Ez7!^ZKF5}U$ofm78g}ROG$WQk;#?5$=+{k zpBw4MU{m_kk+N#WzYToKkw=SR_^nJWEd*aN5kvZ96IMvOUw45&WP5l6-*$*7BLOry z+*fB(PTC#65n7`CFv^azG9+1sg{>x*{S8I!al+lpN&Mo!#rcXl-&Owrk|Yh9zDB6Z zvk-dRH6d`&r6bNEXuxD6%yX^ApMND}HKkP%E$O6mbtbB6gkpo`>86!UOB6R%(`|v& z_zpg%u$oRDQjRpg#ByzYNW%jVD=VUkj;g~>^Ez~@*+b9Kzsko}kQ;o<}XoQB0-unWP{4LKX?G>lgN~tM| zL-LiWO2DBg@w!Re-OCT*$C?z0&9xqxo>r2LBJ7Cdk!yR`Hu|{Yg**tDrA`e(V->8+ z{*>#wC1Gs?i;-c(`i~k<7{RYBP4gmBhAoe<+?$dJH}LlJRkETfs}Z1S>Tx&!04hjO z6kGyVc^3MK|L!0R<trt`b0@_DOV=}lyDvn;dj(Gm4g zv>P|ahDf;^0Te{_u~d=`B{F6=B`J!6o{C16p@cHZ$Vm`y4`sK(fw<$Z3}&0R1W>7% zaXP_A1{sCirRk1Nrtaq6Z3l7G|QN+n?Ow#16&;qm-v*#LW1`;IolSdIUeW0sv zxD#$HN$^oyqFjSRo^Qz0;W=jr#i`uMO0Y*AQ?1H~L+mnNy}h3caU)kCsDn!#Y-tn@ z&xKDQk!3?P61SC2Q5L9F+upUiYsH~lCXlJIjS98d>I{n}8q}37HFaz>&l=K`=0P$5 zLGZHxFQ*Wy%f3kjVM|edSt%(nXxHR!x>0o_1+2@Nj+{0(3_@9`>I#Lefm99gFJQ`b zXvc@VJU|Ftm>U(>l*7lA^ouFHIhnLQzKF@B6 zLdRdqzyH&&zgb__&r`Wq2gq4x3yUaKP*p*h7F^>x!5wULl07?!OhJJt&tvrR9o-vb zWzH#TI=Er_)W5ui%jAaAk~rg4k&pT(>!tw|RS{+k5F(KC96qW^Ku+P>$)NGz-rIVu z6ul%F^q`yjsd$mAhpi(pu7F}0a=M>6bu$!PV=J?~(O|hS$u({-Bp+%ex{odd?=;4QDMM%q3gDb>P>76=|a7-GSY^jC{+(xn(=<@Xr9|QcI4Kj-;ML>3< z4#T-Ro03lo8MH1h#9&Z`R~_3@k&i&4b6tRDOlK0Q#4#ykp0csL%tOwnt1PlO2Eyn? zwCp${X-%OpC^)vBS&|JoQ*_5MO8$7K5r1zAS-Qe@-C?Cry6db zW}FvuG)Y*pNwmRCvpbSVBEx5hIv!BpHyd%SCogq4#M9u)xsEk>h7US19%9Bk%G@4U?QhJ#~63d9> zYQgfpPn}ULGaDktv5f-%0EKwUuUNoq6!6RLK%VT81=8Np=nH5yoToC{ohnR9_Q!%PYzJD*()Kf-? z^t4GwRF2?2;j|P3x#rruWe4sRcXF$ea7i?%$#h*ppjv8&$(Vvo68SXJM-<>Q1PIFD z4OD@s;}5-VaMUSPwT;q1B?gz-?ry1PmcN#$MjvZ8joZ~e0wR6dam}iEn8j1iQoNWpUkm1l96+Ru07l+#;?h!~0v(xt1 zt0}W4GdnU+#{)CF+Nk5->Wi=^9RLHR}fhxVhz4-U%*)fQuiOTLL z?KG$Uqi6h240MADsNE{Yfz1tC#UX{YKVTDmJaxAlUGqTw!kzq+#zuol*6D9l@XS^z zXTho^TuIgmF$k$AD22(gmHR*)qh34t_DK7wC-UorC>vhP)nQfN z=&dtS)EML3KGCowt;ZTo`yDi( zTN@p8=KlbkTay!8Z+EVN2SJZ2RwqRB)pRu}=hC4zl6R(pvQmmvkVpxjHt+EqVL8(% z#+8lRxlow+*Bm#cJweL&O?4zVbX7i7&sK4uv+sW~6*i=7y8VNw@Z-ZZWk+bFqbYr% zicMkursrykI;drh;f6*pQ5sUsv=E{7AxIi~d2w>rO*Q#9c10L}MOc0#hi9zy4P_JI zv~=*{?F96J!=1Q`K83&sy|ni5FTMIy$}z@%Mul6F(vbS(VIMI@PuHF+Sy_{C=xQRB zX((}wC?Tm}#oAcvnTgw`mIHiLQ_-v>&q!0Y)MrKbLGwW*_yp`d4xOkP`g zb}}&?ya+s$bpcTl*K$1@CIMJtj28krU{_&1g`2|Tjwdl_e-NfW zm0TG&0+gqX<6AP~h2PK4n_LQHf>xx_QfqVvtil)&er7+i!gh`Bml&C}5#m zZ!Wn>#U^R;8eGj?T~k*_gwE1DQc_B(MD1esyZ0K7HmioC6$*S=zD#K}jjZXObDt23 zvUqFiu_OLYnQ-|A@`m7CwY)zrJe<*hoD?Y{vRj#*CTaRUn{^}0idsCeS5a4Myh%!T zsP;9EoT1FvkGNCG$}VT@G_I!UuTtpZih7KJT-bru8is+}YO||YsyAXZ*NlHMxBi&+ z)59u%ZiDQm3hal~j8U-)iY%p5Wn&vh9V-DF70?}f>Bn2lZGjS@?WFJJ*9Z6yvXZnJ zFRIn`6a1D*s;q22Mfu6F=$ceM@m}`>Ufgxt`+Oxrs?~$@8V|CXu-uQGGS)AO{{S$` z_3>2Vtj#o4bZiPU-F?#=8`}KZvj&_PC}B+us^PVLri9EX^F|dX$-HPPQYJ?^-E|1l9ilF7Q?uQiBrAxZNE^1yybi)vrq@&%<3TQY#is184vs z=sD!+Rsh!0yUXu+J_NpC?!`U(i9%-9VSG(XF7)Uef3ua>_x08l|tqfl?4UuPHhM^@TM<=2J+ zX_kXNr3GyzRc>DXVIChml_^aiWm`Lz*iP0Y3-RS!6%DkRtK}qYlUOlK(}3c2km9uY zTjZ+gQ%dhG(1v;Lg%_dP?sV*4OQ$tDot!oTY7XY=( z0M`KD_;SCO0d=(8s3Hv^ixEQ%aAB@ijyBlgWDIm7_8<=*4l2?C+l@BkgzOZC#V|&$ zt%neuWu%6iSSi*m2974AP#p9y>Z-~-5;#hT3MNdtM(yFR4iW{gh zf$uV|x^5kh0r{3&+<1{O@1e$7o1*Cj4o0!>{b;at52hHN0h<=CfqGmEl3&9nt*roH3~>@JwQh5c#v@ly{t+<^KT6 z1_|~^9r)wf+f61;5mrV->&FT>-j?tz{{YcUV-w36&kQwG)%EFBhs%fVXc|dYD3L^r z0K4r0eYYG6?>nvL422;;8WV27a>3G-q>yX>)BqMNyH%X<@l%6TQ+(7ubrvUD3z_N5 z$0Wie0_vp7g!_K0atto143ksiZ3Q|2`>Qvp9Jx`D@aeHkBLSB@$6HAqeGUPZ7j%_m zi|uA&zEmgyGBH2ujZYKq(#6A)Oj5n%Nnsj5)JH{El{Zc^W`D$@&Qw)(mDq-9q>7%l zhNd$eB|Ho~sH3M#0SpE<3$S-S_564{R$$u$K|3e_-HP5(QbfqA$jm)Z$1=Wg&6spB zR_wwnDzMmTsnS#a^U7jWw0`LOHV3x{Ojspo1Rb;sUS_m7QyUF8R{DU>6>%@g<@{2V zvE8L0a>4SQX&eR2@{;p${(lOkuV3qCd19FpZhbp|0 zCu*_vr;(noigEOz7<#zPsUO0{;M)6O54{ec1ZdhVdw$ zwmp>S{;e~7(q3Mi=6dKD4Ycz@;dCUM6pv7E+m#tIWA7gNy0fwl2{iXZ>dP~!Qx`<@ zD>9X6jT}`9E#aU|b>%;jr2haI_tULs#y->TteDTMEW=tO-OucU3Rra5CCua3eou{)?&9fnu{4UaFJ{^*X?F*yluTkmM(b^af&nAA)NRTQav!s=3Vi8YEZRlQxpCa9vU$r!Blb0xgW z$Pz~$=(&xbOOGF;j+}vwp;Vb$$nk(v@Tl>6#_G)rr8F20F}H7*43kqr`;?ml?${Bf z?Z@7b>3wB&&N=F9qRP0&CV~D{rKqHdqt@p@H5voTySvONebk|y z>wFoC&OKjslB%ezSq~VBXC_#wu&OmsjcZ&3e{W;Tqj%Xz`>W3HUBcBdP4DV|udP_Y zGNx=vEpJV891<1UqYi>9WGQ`a7T32IBPV4d0{%3KS=->^ znD$p1ey?>V0U2JKW-8Le`9~5+<{QAZhW72ozmqa{EPLt1Zw1dsKH660p0V{pp~$4l zSdJRA1_3ImPy{FZ0{!l7@#mM4+mVW?hxd~27)Q8%G~Xt9>MkLR%}t46nB)|!yZ&%H z2;?L80;>xf>C68BFJvbI4JS@@aH1p;&z&gc>Lz!?XkJ_s0>*JUn$bNpo?@+-+}O01 zRvb)nrqppFmW=h_JR)jMA5*%qQBPHejGc-Vg<_IpHBcc-p9Xdsj^y&gC2D@*NtL}1 zKmi1gN=Vi97pe7Z&iOkT^I_VuB|U1Q*ysxdU^fx3E&QdJ`-MIIrMM(`2=;z8j}YqD zS0ST%Df)GeRKXm_->0pO-5+g>U(EXic=Jigt!8x&eJbO5ZWNs)9(`(VJDz%}fh9CF z*;5$Iv{fi1j;92~5t$sXypnEkbR$m#%{7#;t)vRNw}RmVk3O`=Pt*>r%M;W`(wxI8 zC}w7wzB>R4_6AX|y||%SOCbHj*-ec3)f0iJ&z!o$h%~WNbh9whD*`1k)kK@DcM!+U zu^e?7Yd_Ky!t-}jBqY(c^mm-ITzKYok2K*Gc~z&Rqo>1`y~Og!&{Y{^Z_%@D&6D4=(~qwhQ@ z-8(%uC!~rp-mA{?)DhEE*XHM1iu#!F?4Mg!T1PPoc~;U~k+=pT*Y9pgf0IA}l|@GA zyk4Rp*JiJ%P{b9o4lL!5kdGY8W^UFuU~YY!(Xwy)LX>|oa10V@PnK)*twm!}Vp&rZ zz-Z%1B&n;GZqB1bDy@Hd)*NAWO~%k`LosrAidI$6n`x<%Y$pxHu`1+bXlW3&IAh$9 zWRlhc!1v<`vuKet{{Zs`0NYQEn7Y}E(R{o;GpmvdBeb*=Lb5Mw8;LGEYo|5*y@9nt zoK|&myfhz5;%NG_K!&njp5rx&pgY6!X&2{T`A2CEkh@iCBzqNGo25)DHr(h zugTky_a;2QN_iQx$UkZJ(u$gHzQG)F)O2GWcR{wEX2fB-zUzV)%s01>6DrQwhzm_P zoZ{p92AhHF#YD!bdM%DgG_Sn0bH)bi?z!6fanH(H#A_V-SCN|BOz1T>Y{%*fO5Y+* zjpL792H1R&Q?&cQTEH+G-?-x`u(bpGp!fb1ty#^*T;&6cGl#g1|lP zuP&QwP#`Hh`cp1u*FVICbL&nSaxSxC6+T6FM#SjiQpP2kyvoeuZPcdlMZrGx`DHU~ zHV}F8rkTthCt>!`iAx@7!>MbAEz{bm6znT6^Es%Jn1DlH$#&ewLKle5vI!9sq+Yl< z8cV({)TpLk<-It>>**&@(Bss&&FSFWWT`<=!axQc{x|>S>bjWVvXO?Nd-5 zvu>c30?uqrzN=e`e=LEuRE>F~r}$60oW@}4gn~)xvSUh+#v~W5h_3Q4vru)vhc>Hb zzosh3F?0jqKI-E&er)|5wK)nlGYhaxUYIhQ+ulM4eF)`6x<9A!uOi{Xa6zopwOPGb zv^_ra;Xh(HaY#X82i!-6$HSE@C;DUGUN>q^)E{+alM&CpOQjc2;X=$zsU|N2Ftvs6 zeLItGIGZqkinMbgL})(h&n8^!Rw)cKQFOU68cD96ejSU`vaE^$WosP`m~y?tVB)&k zZk$lT2i;9I89S_0q!;N62}O<97lnmZf<=X|ZdMyl@l9!JaYyZ@Y(Fh#46B{;O*3J8etR3jXlg5J>O@Nf zQr5<=Aax{rpzF&#l&!PJ3TX;cZX|5RkM=2)Dk|Qxrn-is9ihZQrGknBxS5n)UI(!o zzy&s&1_WQQw0dqdmDz z6lNelu#c!QX0_>8iwY6mGJ@)G<6r;P2G=rTcy&$}m?^TH^pnwQlsF;UwM zoACr+FTD*^l3j=gK_`XJ3sb(AN*g{Dsol`E7=ARmqWm|ySwPXUV^!5Iq$3)Ni5BAD zXl?9$qn3MoE(Q}%+irESAHI~>f8phjF}Z5#;aTCHo)K3{^;K@-W>TxR!%zyF{4K;P z-mA2yZ92Wzw44XNr%C8*B2t4LEOQ9MG6MCFe!|+1XO9)LpT2gQME35m0mB;g7oog? z0-;k{B?Xxp3__ts@^@=(K;!Ob?*W0Tx4W%IIMy6j(I!QxsuN8$Pr3!;mk^YfBTEv0 zk1WP~838eRxO50i8VX#K$[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/05-coordinate_systems/scripts/reset_build.ps1 b/05-coordinate_systems/scripts/reset_build.ps1 new file mode 100644 index 0000000..975852d --- /dev/null +++ b/05-coordinate_systems/scripts/reset_build.ps1 @@ -0,0 +1,7 @@ +mv .\subprojects\packagecache . +rm -recurse -force .\subprojects\,.\builddir\ +mkdir subprojects +mv .\packagecache .\subprojects\ +mkdir builddir +cp wraps\*.wrap subprojects\ +meson setup --default-library=static --prefer-static builddir diff --git a/05-coordinate_systems/scripts/reset_build.sh b/05-coordinate_systems/scripts/reset_build.sh new file mode 100644 index 0000000..89931e7 --- /dev/null +++ b/05-coordinate_systems/scripts/reset_build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +mv -f ./subprojects/packagecache . +rm -rf subprojects builddir +mkdir subprojects +mv -f packagecache ./subprojects/ && true +mkdir builddir +cp wraps/*.wrap subprojects/ +# on OSX you can't do this with static +meson setup --default-library=static --prefer-static builddir diff --git a/05-coordinate_systems/scripts/setup.ps1 b/05-coordinate_systems/scripts/setup.ps1 new file mode 100644 index 0000000..050d716 --- /dev/null +++ b/05-coordinate_systems/scripts/setup.ps1 @@ -0,0 +1,4 @@ +mkdir builddir +mkdir subprojects +cp wraps/*.wrap subprojects +meson setup -Ddefault_library=static builddir diff --git a/05-coordinate_systems/scripts/setup.sh b/05-coordinate_systems/scripts/setup.sh new file mode 100644 index 0000000..7881736 --- /dev/null +++ b/05-coordinate_systems/scripts/setup.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +set -ex + +mkdir subprojects +mkdir builddir +cp wraps/*.wrap subprojects/ +meson setup builddir diff --git a/05-coordinate_systems/scripts/watch_build.sh b/05-coordinate_systems/scripts/watch_build.sh new file mode 100644 index 0000000..44a5516 --- /dev/null +++ b/05-coordinate_systems/scripts/watch_build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +fswatch -o *.cpp | while read num +do echo ">>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/05-coordinate_systems/scripts/windows_setup.ps1 b/05-coordinate_systems/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/05-coordinate_systems/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/05-coordinate_systems/shaders/3.3.shader.fs b/05-coordinate_systems/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/05-coordinate_systems/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/05-coordinate_systems/shaders/3.3.shader.vs b/05-coordinate_systems/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/05-coordinate_systems/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/05-coordinate_systems/shaders/4.2.texture.fs b/05-coordinate_systems/shaders/4.2.texture.fs new file mode 100644 index 0000000..de1f86e --- /dev/null +++ b/05-coordinate_systems/shaders/4.2.texture.fs @@ -0,0 +1,12 @@ +#version 330 core + +out vec4 FragColor; +in vec2 TexCoord; + +uniform sampler2D texture1; +uniform sampler2D texture2; + +void main() +{ + FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2); +} diff --git a/05-coordinate_systems/shaders/4.2.texture.vs b/05-coordinate_systems/shaders/4.2.texture.vs new file mode 100644 index 0000000..85c9de7 --- /dev/null +++ b/05-coordinate_systems/shaders/4.2.texture.vs @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTexCoord; + +out vec2 TexCoord; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/05-coordinate_systems/src/data.hpp b/05-coordinate_systems/src/data.hpp new file mode 100644 index 0000000..c58ace5 --- /dev/null +++ b/05-coordinate_systems/src/data.hpp @@ -0,0 +1,47 @@ +#pragma once +#include + +float vertices_3d[] = { + // vertex coords // texture coords + -0.1f, -0.1f, -0.1f, 0.0f, 0.0f, + 0.1f, -0.1f, -0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 0.0f, + + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 1.0f, + -0.1f, 0.1f, 0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + + -0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, 0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f +}; diff --git a/05-coordinate_systems/src/dbc.cpp b/05-coordinate_systems/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/05-coordinate_systems/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/05-coordinate_systems/src/dbc.hpp b/05-coordinate_systems/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/05-coordinate_systems/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/05-coordinate_systems/src/main.cpp b/05-coordinate_systems/src/main.cpp new file mode 100644 index 0000000..75bf078 --- /dev/null +++ b/05-coordinate_systems/src/main.cpp @@ -0,0 +1,214 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include "data.hpp" +#include "physics.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + Shader shader; + unsigned int VAO = 0; + unsigned int VBO = 0; + unsigned int texture1 = 0; + unsigned int texture2 = 0; +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + return window; +} + +void processInput(GLFWwindow *window, BoxTest &box) { + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + for(size_t i = 0; i < BODY_COUNT; i++) { + box.bodies[i]->ApplyForceToCenter(force, true); + box.bodies[i]->ApplyTorque(0.1f, true); + } + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + glEnable(GL_DEPTH_TEST); + + Config config{{"shaders/4.2.texture.vs", "shaders/4.2.texture.fs"}}; + + unsigned int VBO = 0; + unsigned int VAO = 0; + + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + + glBindVertexArray(VAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_3d), vertices_3d, GL_STATIC_DRAW); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + config.texture1 = load_texture("resources/textures/container.jpg"); + config.texture2 = load_texture("resources/textures/awesomeface.png"); + + config.shader.use(); + config.shader.setInt("texture1", 0); + config.shader.setInt("texture2", 1); + + config.VAO = VAO; + config.VBO = VBO; + + return config; +} + +void render(GLFWwindow* window, const Config& config, BoxTest& box, b2World& world) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, config.texture1); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, config.texture2); + + config.shader.use(); + + // this is position + float time = glfwGetTime(); + Box2d_step_world(world); + + + glm::mat4 view = glm::mat4(1.0f); + view = glm::translate(view, glm::vec3(0.0f, 0.0f, -3.0f)); + config.shader.setMat4("view", view); + + glm::mat4 projection = glm::mat4(1.0f); + projection = glm::perspective(glm::radians(45.0f), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); + config.shader.setMat4("projection", projection); + + glBindVertexArray(config.VAO); + + for(unsigned int i = 0; i < BODY_COUNT; i++) { + glm::mat4 model = glm::mat4(1.0f); + + // get position from box + b2Vec2 position = box.bodies[i]->GetPosition(); + float angle = box.bodies[i]->GetAngle(); + + model = glm::translate(model, glm::vec3(position.x, position.y, 0.0f)); + model = glm::rotate(model, angle / 5.0f, glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(time * 10.0f), glm::vec3(0.0f, 1.0f, 1.0f)); + + config.shader.setMat4("model", model); + + glDrawArrays(GL_TRIANGLES, 0, 36); + } + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.VAO); + glDeleteBuffers(1, &config.VAO); + glDeleteBuffers(1, &config.VBO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + + auto config = setup(); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box); + render(window, config, box, world); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/05-coordinate_systems/src/physics.cpp b/05-coordinate_systems/src/physics.cpp new file mode 100644 index 0000000..daa8f87 --- /dev/null +++ b/05-coordinate_systems/src/physics.cpp @@ -0,0 +1,49 @@ +#include "physics.hpp" + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + for(size_t i = 0; i < BODY_COUNT; i++) { + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.5f); + box.bodies[i] = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.bodies[i]->CreateFixture(&fixtureDef); + } + + return box; +} + +void Box2d_step_world(b2World& world) { + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); +} diff --git a/05-coordinate_systems/src/physics.hpp b/05-coordinate_systems/src/physics.hpp new file mode 100644 index 0000000..65ca81a --- /dev/null +++ b/05-coordinate_systems/src/physics.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +#define BODY_COUNT 20 + +struct BoxTest { + b2Body *walls[4]; + b2Body *bodies[BODY_COUNT]; +}; + +struct BoxTest Box2d_setup(b2World &world); +void Box2d_step_world(b2World& world); diff --git a/05-coordinate_systems/src/shader.cpp b/05-coordinate_systems/src/shader.cpp new file mode 100644 index 0000000..ecbb1c3 --- /dev/null +++ b/05-coordinate_systems/src/shader.cpp @@ -0,0 +1,109 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" +#include +#include +#include + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} + +void Shader::setMat4(const std::string &name, const glm::mat4& mat) const { + unsigned int loc = glGetUniformLocation(ID, name.c_str()); + glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(mat)); +} diff --git a/05-coordinate_systems/src/shader.hpp b/05-coordinate_systems/src/shader.hpp new file mode 100644 index 0000000..d1aa2dc --- /dev/null +++ b/05-coordinate_systems/src/shader.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void setMat4(const std::string &name, const glm::mat4& what) const; + void cleanup(); +}; diff --git a/05-coordinate_systems/src/stb_image.cpp b/05-coordinate_systems/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/05-coordinate_systems/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/05-coordinate_systems/src/stb_image.h b/05-coordinate_systems/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/05-coordinate_systems/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/05-coordinate_systems/tests/bad_shader.vs b/05-coordinate_systems/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/05-coordinate_systems/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/05-coordinate_systems/tests/main.cpp b/05-coordinate_systems/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/05-coordinate_systems/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/05-coordinate_systems/tests/meson.build b/05-coordinate_systems/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/05-coordinate_systems/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/05-coordinate_systems/tests/shader_tests.cpp b/05-coordinate_systems/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/05-coordinate_systems/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/05-coordinate_systems/wraps/box2d.wrap b/05-coordinate_systems/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/05-coordinate_systems/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/05-coordinate_systems/wraps/fmt.wrap b/05-coordinate_systems/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/05-coordinate_systems/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/05-coordinate_systems/wraps/fuc2.wrap b/05-coordinate_systems/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/05-coordinate_systems/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/05-coordinate_systems/wraps/glfw.wrap b/05-coordinate_systems/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/05-coordinate_systems/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/05-coordinate_systems/wraps/glm.wrap b/05-coordinate_systems/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/05-coordinate_systems/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep diff --git a/06-camera/.gitignore b/06-camera/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/06-camera/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/06-camera/.vimrc_proj b/06-camera/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/06-camera/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/06-camera/KHR/khrplatform.h b/06-camera/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/06-camera/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/06-camera/LICENSE b/06-camera/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/06-camera/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/06-camera/Makefile b/06-camera/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/06-camera/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/06-camera/glad/glad.cpp b/06-camera/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/06-camera/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/06-camera/glad/glad.h b/06-camera/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/06-camera/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/06-camera/meson.build b/06-camera/meson.build new file mode 100644 index 0000000..084c32b --- /dev/null +++ b/06-camera/meson.build @@ -0,0 +1,95 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', + 'src/physics.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/06-camera/resources/textures/awesomeface.png b/06-camera/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 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 Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/06-camera/resources/textures/container.jpg b/06-camera/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys 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[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/06-camera/scripts/reset_build.ps1 b/06-camera/scripts/reset_build.ps1 new file mode 100644 index 0000000..975852d --- /dev/null +++ b/06-camera/scripts/reset_build.ps1 @@ -0,0 +1,7 @@ +mv .\subprojects\packagecache . +rm -recurse -force .\subprojects\,.\builddir\ +mkdir subprojects +mv .\packagecache .\subprojects\ +mkdir builddir +cp wraps\*.wrap subprojects\ +meson setup --default-library=static --prefer-static builddir diff --git a/06-camera/scripts/reset_build.sh b/06-camera/scripts/reset_build.sh new file mode 100644 index 0000000..89931e7 --- /dev/null +++ b/06-camera/scripts/reset_build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +mv -f ./subprojects/packagecache . +rm -rf subprojects builddir +mkdir subprojects +mv -f packagecache ./subprojects/ && true +mkdir builddir +cp wraps/*.wrap subprojects/ +# on OSX you can't do this with static +meson setup --default-library=static --prefer-static builddir diff --git a/06-camera/scripts/setup.ps1 b/06-camera/scripts/setup.ps1 new file mode 100644 index 0000000..050d716 --- /dev/null +++ b/06-camera/scripts/setup.ps1 @@ -0,0 +1,4 @@ +mkdir builddir +mkdir subprojects +cp wraps/*.wrap subprojects +meson setup -Ddefault_library=static builddir diff --git a/06-camera/scripts/setup.sh b/06-camera/scripts/setup.sh new file mode 100644 index 0000000..7881736 --- /dev/null +++ b/06-camera/scripts/setup.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +set -ex + +mkdir subprojects +mkdir builddir +cp wraps/*.wrap subprojects/ +meson setup builddir diff --git a/06-camera/scripts/watch_build.sh b/06-camera/scripts/watch_build.sh new file mode 100644 index 0000000..44a5516 --- /dev/null +++ b/06-camera/scripts/watch_build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +fswatch -o *.cpp | while read num +do echo ">>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/06-camera/scripts/windows_setup.ps1 b/06-camera/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/06-camera/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/06-camera/shaders/3.3.shader.fs b/06-camera/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/06-camera/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/06-camera/shaders/3.3.shader.vs b/06-camera/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/06-camera/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/06-camera/shaders/4.2.texture.fs b/06-camera/shaders/4.2.texture.fs new file mode 100644 index 0000000..de1f86e --- /dev/null +++ b/06-camera/shaders/4.2.texture.fs @@ -0,0 +1,12 @@ +#version 330 core + +out vec4 FragColor; +in vec2 TexCoord; + +uniform sampler2D texture1; +uniform sampler2D texture2; + +void main() +{ + FragColor = mix(texture(texture1, TexCoord), texture(texture2, TexCoord), 0.2); +} diff --git a/06-camera/shaders/4.2.texture.vs b/06-camera/shaders/4.2.texture.vs new file mode 100644 index 0000000..85c9de7 --- /dev/null +++ b/06-camera/shaders/4.2.texture.vs @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTexCoord; + +out vec2 TexCoord; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/06-camera/src/data.hpp b/06-camera/src/data.hpp new file mode 100644 index 0000000..c58ace5 --- /dev/null +++ b/06-camera/src/data.hpp @@ -0,0 +1,47 @@ +#pragma once +#include + +float vertices_3d[] = { + // vertex coords // texture coords + -0.1f, -0.1f, -0.1f, 0.0f, 0.0f, + 0.1f, -0.1f, -0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 0.0f, + + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 1.0f, + -0.1f, 0.1f, 0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + + -0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, 0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f +}; diff --git a/06-camera/src/dbc.cpp b/06-camera/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/06-camera/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/06-camera/src/dbc.hpp b/06-camera/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/06-camera/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/06-camera/src/main.cpp b/06-camera/src/main.cpp new file mode 100644 index 0000000..f206fa9 --- /dev/null +++ b/06-camera/src/main.cpp @@ -0,0 +1,335 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include "data.hpp" +#include "physics.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Camera { + glm::vec3 pos = glm::vec3(0.0f, 0.0f, 3.0f); + glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f); + glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f); + glm::vec3 direction = glm::vec3(0.0f, 0.0f, 0.0f); + + float pitch = 0.0f; + float yaw = -90.0f; + float speed = 0.05f; + float lastX = 400; + float lastY = 300; + float fov = 45.0f; + bool firstMouse = true; + + glm::mat4 lookAt() { + return glm::lookAt(pos, pos + front, up); + } + + void forward() { + pos += speed * front; + } + + void back() { + pos -= speed * front; + } + + void left() { + pos -= glm::normalize(glm::cross(front, up)) * speed; + } + + void right() { + pos += glm::normalize(glm::cross(front, up)) * speed; + } + + void update(float deltaTime) { + speed = 2.5f * deltaTime; + } + + void mouse_move(double xpos, double ypos) { + if(firstMouse) { + lastX = xpos; + lastY = ypos; + firstMouse = false; + } + + float xoffset = xpos - lastX; + float yoffset = lastY - ypos; + lastX = xpos; + lastY = ypos; + + const float sensitivity = 0.1f; + xoffset *= sensitivity; + yoffset *= sensitivity; + + yaw += xoffset; + pitch += yoffset; + + if(pitch > 89.0f) pitch = 89.0f; + if(pitch < -89.0f) pitch = -89.0f; + + direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); + direction.y = sin(glm::radians(pitch)); + direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); + + front = glm::normalize(direction); + } + + void mouse_scroll(double xoffset, double yoffset) { + fov -= (float)yoffset; + + if(fov < 1.0f) fov = 1.0f; + if(fov > 90.0f) fov = 90.0f; + } +}; + +struct Config { + Shader shader; + unsigned int VAO = 0; + unsigned int VBO = 0; + unsigned int texture1 = 0; + unsigned int texture2 = 0; + Camera camera{}; + float deltaTime = 0.0f; + float lastFrame = 0.0f; + + void updateDelta() { + float currentFrame = glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; + } +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +void mouse_callback(GLFWwindow *window, double xpos, double ypos) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_move(xpos, ypos); +} + +void scroll_callback(GLFWwindow *window, double xoffset, double yoffset) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_scroll(xoffset, yoffset); +} + + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); + glfwSetCursorPosCallback(window, mouse_callback); + glfwSetScrollCallback(window, scroll_callback); + + return window; +} + + +void processInput(GLFWwindow *window, BoxTest &box, Camera& camera) { + + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + for(size_t i = 0; i < BODY_COUNT; i++) { + box.bodies[i]->ApplyForceToCenter(force, true); + box.bodies[i]->ApplyTorque(0.1f, true); + } + } + + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { + camera.forward(); + } + + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { + camera.back(); + } + + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { + camera.left(); + } + + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { + camera.right(); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + glEnable(GL_DEPTH_TEST); + + Config config{{"shaders/4.2.texture.vs", "shaders/4.2.texture.fs"}}; + + unsigned int VBO = 0; + unsigned int VAO = 0; + + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + + glBindVertexArray(VAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices_3d), vertices_3d, GL_STATIC_DRAW); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + config.texture1 = load_texture("resources/textures/container.jpg"); + config.texture2 = load_texture("resources/textures/awesomeface.png"); + + config.shader.use(); + config.shader.setInt("texture1", 0); + config.shader.setInt("texture2", 1); + + config.VAO = VAO; + config.VBO = VBO; + + return config; +} + +void render(GLFWwindow* window, Config& config, BoxTest& box, b2World& world) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, config.texture1); + glActiveTexture(GL_TEXTURE1); + glBindTexture(GL_TEXTURE_2D, config.texture2); + + config.shader.use(); + + Box2d_step_world(world); + + // time is used for fake 3d rotation + float time = glfwGetTime(); + + config.camera.update(config.deltaTime); + glm::mat4 view = config.camera.lookAt(); + + config.shader.setMat4("view", view); + + glm::mat4 projection = glm::mat4(1.0f); + // fov, aspect, near plane, far plane + projection = glm::perspective(glm::radians(config.camera.fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); + config.shader.setMat4("projection", projection); + + glBindVertexArray(config.VAO); + + for(unsigned int i = 0; i < BODY_COUNT; i++) { + glm::mat4 model = glm::mat4(1.0f); + + // get position from box + b2Vec2 position = box.bodies[i]->GetPosition(); + float angle = box.bodies[i]->GetAngle(); + + model = glm::translate(model, glm::vec3(position.x, position.y, 0.0f)); + model = glm::rotate(model, angle / 5.0f, glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(time * 10.0f), glm::vec3(0.0f, 1.0f, 1.0f)); + + config.shader.setMat4("model", model); + + glDrawArrays(GL_TRIANGLES, 0, 36); + } + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.VAO); + glDeleteBuffers(1, &config.VAO); + glDeleteBuffers(1, &config.VBO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + auto config = setup(); + + glfwSetWindowUserPointer(window, &config.camera); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box, config.camera); + render(window, config, box, world); + config.updateDelta(); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/06-camera/src/physics.cpp b/06-camera/src/physics.cpp new file mode 100644 index 0000000..daa8f87 --- /dev/null +++ b/06-camera/src/physics.cpp @@ -0,0 +1,49 @@ +#include "physics.hpp" + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + for(size_t i = 0; i < BODY_COUNT; i++) { + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.5f); + box.bodies[i] = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.bodies[i]->CreateFixture(&fixtureDef); + } + + return box; +} + +void Box2d_step_world(b2World& world) { + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); +} diff --git a/06-camera/src/physics.hpp b/06-camera/src/physics.hpp new file mode 100644 index 0000000..65ca81a --- /dev/null +++ b/06-camera/src/physics.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +#define BODY_COUNT 20 + +struct BoxTest { + b2Body *walls[4]; + b2Body *bodies[BODY_COUNT]; +}; + +struct BoxTest Box2d_setup(b2World &world); +void Box2d_step_world(b2World& world); diff --git a/06-camera/src/shader.cpp b/06-camera/src/shader.cpp new file mode 100644 index 0000000..ecbb1c3 --- /dev/null +++ b/06-camera/src/shader.cpp @@ -0,0 +1,109 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" +#include +#include +#include + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} + +void Shader::setMat4(const std::string &name, const glm::mat4& mat) const { + unsigned int loc = glGetUniformLocation(ID, name.c_str()); + glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(mat)); +} diff --git a/06-camera/src/shader.hpp b/06-camera/src/shader.hpp new file mode 100644 index 0000000..d1aa2dc --- /dev/null +++ b/06-camera/src/shader.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void setMat4(const std::string &name, const glm::mat4& what) const; + void cleanup(); +}; diff --git a/06-camera/src/stb_image.cpp b/06-camera/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/06-camera/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/06-camera/src/stb_image.h b/06-camera/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/06-camera/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/06-camera/tests/bad_shader.vs b/06-camera/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/06-camera/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/06-camera/tests/main.cpp b/06-camera/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/06-camera/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/06-camera/tests/meson.build b/06-camera/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/06-camera/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/06-camera/tests/shader_tests.cpp b/06-camera/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/06-camera/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/06-camera/wraps/box2d.wrap b/06-camera/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/06-camera/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/06-camera/wraps/fmt.wrap b/06-camera/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/06-camera/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/06-camera/wraps/fuc2.wrap b/06-camera/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/06-camera/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/06-camera/wraps/glfw.wrap b/06-camera/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/06-camera/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/06-camera/wraps/glm.wrap b/06-camera/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/06-camera/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep diff --git a/07-model-loading/.gitignore b/07-model-loading/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/07-model-loading/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/07-model-loading/.vimrc_proj b/07-model-loading/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/07-model-loading/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/07-model-loading/KHR/khrplatform.h b/07-model-loading/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/07-model-loading/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/07-model-loading/LICENSE b/07-model-loading/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/07-model-loading/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/07-model-loading/Makefile b/07-model-loading/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/07-model-loading/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/07-model-loading/assets/popcorn_model_a.glb b/07-model-loading/assets/popcorn_model_a.glb new file mode 100644 index 0000000000000000000000000000000000000000..ae67d1554cce0a5fe6a4ea2b7c9cbd9d5f765777 GIT binary patch literal 18084 zcmc&)2Uu0dwq7HGU9rSo@Yo~5X_N!(837wuAb_A^LqH%ZC}2UXv0z0+R4^JlV1gwY zJA1Z?1r<%K*rUc8jl_x?_4?+VBxP*8n);no6lN~ilk*ouahxQMar11z()x<}PVm?i< zCJ*}OU8-hObW*IP=^y&QkrDCHPFk&wJt#3DIU?Eeq;Rd1o7PRI zb#>RfySkfP++6gITJyhuakI{o6C>i2Mp|3yoZPjp29w@s(CJ-FIu{oMYh^U*3?{AC z)y-gVHyI5sj-9klTD?K*ZZf%OO@F!G@%M=wHg@>%=)};t=<$|*A`?c9PKb|=PYy{L%_i7Ir+0PK zL?(=lXG>{xXM9w|1oJ#Q8C_jnT(t&QgPW_##XNZPxLu6y?re}IqpM!0cXP8$g-P$u zMyq#oH|limt}bi_N5!$#4QF#=)M}0HZf@>c7dNfR-C#1$laV!aHMz1SV4dl8?iQbm zyUx{U&>D>T6&zlB(f{!RFvkhw;C)*Z-yV`hR)8;eTpxaayL) z)x<*ikLL&bdiU}U(wKwxpCjNG#Pw}`|T zbFvwXCReuP*6C2u`1kJAwl}cl{qW&BovW)+{R`*}?(B8>w`VECvh9NrusF3&#~)L{ zjbG<#GU!<#J2*JB_5twm>jN22wX$Ary1i0oZ>)yDI{QRoXq+e z5zlVBQ8vHx^3QKlHN0zSmbFi+hELL+pzXW(7RKO>R1Ghzev+;>*cSTB9#jo)w{MN* zeH=<37OLSsAywspTdx+Hb4?B3Q(cytom?iFbM3Ek*O02X^VX}9IoH(iZPg{*;ADMl z&O0@Htj}k7-46lSoP%n3+OdT=&oB(@SU#%Z!BYZo;*2)9X6Xn?4d1@80c~0RofH@s zj{gpCxyhUEoYOUqsdL<#9H6V(w`v|GSG+4L2N4z{`9HHbtJM zYIsM_HF)TnsklewMN|!+N%!I4vMgLxb3<0cOYmY`ZBGpD5E>$>;jvAo%MV`lmd*7_ z4PSFPmU>VVWot*(@OMd@=-`fNG_Uh&s)kS3XVMy{(`e^9?o%ym}QqwA3p#Tn=g`1c$mzHSt5ItBrp^Q9)U+}55vwg~c-tyza%R0O zOKnlZBil}suLrE9pRUQmYWT#>&hnd$oz3xy)$masW4vs;%(T=8HT-4rM^cqLt+2U1 zsNqHZ=16O2F16GLH9X66m*iYhg#B23P{SV#J14o`yN|1}`k;oVYBx$bZFb`JtUjpW z$IoXLzN)y^QXkat$nd#x!Q!dZ&*x{VhA-W7Kwc1fmgchhpoZVJ3zO$9JxUEtDpNK5 z?%j0x(l;w+!jiut{@&({{7XrHOU{b;SKrvvy$zRH@>Im_W;COQ zi1n7-RKxwJ-<4N1NU-Fl8b1E64Gupw$C7Iz?su&^&TpDY&ELQxj&r_}w!hO^a!SOL z*E}rDjY+oTks3bt?P9rjWCKecso_1GY-w!kd6qm`;9$s;v9COLp!ce-Ht zomInU4QNUG4$8CSks9vQeE@BE;i80#j!A0x-INSEPtzL@JrqIJ@W<@;GLGa(_X4j| zH9X_-3|cUtKduv%F00{nvq#FuGcI^FxObk4c>3W$`j4{u_<-vnPc{5@P&%#ptTLY6 zcn?*>pO361(L-65TJ%?We5(sm%XUL7zf=D%KBc!Jr45}$XJkE~YWQ#a9!i7j7gBuj zYpRAQCFoQchQe|z@r^mn*>=sC-I)PeLGUVn#Q?c`9{q4Lzi zCDl99zr*A5KJ%Pod&+asfpzph$&2&TEc0OAyQ$&njoMr0-~4T+hVLGbW6_)UZff|^ zvJ)1)dGDr%!_88QzB2nZQ^OP3xq~@=9ND*-8b0d6AiQs<4jY5AWHr2>=Pl`YM?D^p zd{I`zW1VV9pZjZY_7~Aq4bN`bNh_1dbu(4Nhp&4nt(dIE zQA2i9HN4}zZrI_xGyZJ&4yuNi=FGzGd!2EKPa0Lj%MO2zubp$o-iMk}HGI;Y>3G{? zExtNGTUNu%hONT0d(D*IS4|>sdsL^b_co>@zL==o+#XLiO$<{!`oE^e$PlIe*IBfN z<~cRT4!|_>yR~q|j1TvEVJ+0gVecjof4g0Ddb0%bu6}jNe!{0paKjDs?9}m=xMOWC z`sS1BDp6zlP~%a5BGN=0d5T-U?tlmPA4GWl@6Z0dA6_%iHlB>g$;ICU|9)O>eb$}s z0VJZ)Vw{m~qwtzB&w`|J0Y1dHZCkRs#Vn~TIh164UsYN8x&$Bjb})&nKNE-czJ%XC z2_qY)=TraIZ}5#3{mIFdU8u+D&UEp`J|yy&n#%0e6R7TGUD747JMllai{7}@gET*g zl!=Ril+(*HaMY2vc$Y)8VteTpo)hrQ>)4}vm>R>0rtK8G?8<$dxy_q=IrlLROsz`} zENn|AgubIgy&Or}o`o1TI1{JlMv^_zMy|f!MRATZk~=$^$y>r*6uWxSWYPhJM#~d$ zr+YoHePt6qx_6wCckebnJmkIX`0X&I}k19C&%2#OufXY$6#;it(JqwG>{%#|*FG{d_F#TlJ&Vp+*2c z*daw38roj2`fx;H$+uHU-t!*HjtvWFc)Ob9_VPZ;^!lITrBT%gufIIajZB<38vkbB zp73pLPE=EzR|2`Vs-wbdeoW{~T%S}@jE@`RlS%R9TiAsCSWfZ!W3@bq13r!)&8w;K z`m53)a>RI+o*%n}@@++P&iBK&%`84Alc61GX6;mk&$ZGaztY5oSb5Fzi=Q7pr$lY@ zT2xdHg$F6l)5l{zkLK%hsZB^lD2N6D}_8bC^Z-BVhSK9%60NNN7VFT8RY=lkK? zPVoCwvWrSl+}97md`;uyw(^OwBs@2r=5O2O#m8i`J7bh{HZgSP?ZglA=uu`IJ{8dt zUo9J}RJ)DHjN^UCDwaEZ9`XJ*g>}izb%CTwVwl8h_#DB$mC1biF)5v3tMGb0UqpId zBZ`?dZH`ODIYSgX7E65m@HKho=fjnNz#lEO+%-8?X?h|H2J({45 z^VvjWp8O)8VLYqV1vpLzv9P@G8P=?#>OA|H|#ItN#s(m>(;hnK&{Wn+4h?BZ>d*Q6gBMy~An z0)NN+jeoe0m-jP~d&epgUjKGUA96N31CJ@LNO-*{#`u2two8+j>~HrrTlVTP^@Ezz zt=>&Ku9HEz-q`+w+BL8D4t({O=A`Z-1L13ts2^UhUs{1Q?-xp{t@fjQTfYAAnnp`) zNnE>@WKKj~g|9!np08JYY>V28Vu`Osd>o2$kgs)oE#mdl{1-@Lx-?Oo+4lfnb9gNRalidd0Vm_FLtt8RICoK0H<7=bx`3@A_Vmo%0jPSypFwKVK_&O@moA z=*E7jWV6W@i)u^$GEcclVi)piUn_;z^XtpE<@Nmf-g)UD6?fcDuOCZLM(6C1yp?W> zbgab(`Oeo0UeD)#&gedc`A=?1OUl&>Uc=`;uU{LsSH4oCH@P%bTpxJN`b!t&fWmm< zdrVv(4z4;RJErz0&yQCmyq;fQz9#VN%eS?^(8_C8vpsUyvnixn4@F8$4^~dHZx}w` z`C7s2L)-QAdRXF2+E(%)d>!E1iZpy3_@zrv`ZRAMdHP;2^L{?ZTMa3e=dJ8Ynkfzn zuNTFqsI4e}`QKAMXZgJ2HN2nCFJ8m{cJnzU(!X(XBzHYl(>r%NDtudh?f8B~ImQ20 z@_E7M5wGEMir4cRJ}>w@>b5@{YYRFR4hTtB`0rj`&ujR+c=O2$I{3?A+{Hg$fmm;{ zfA>G=B;U)J*YJ5E(%14IK}@L!>9Uj}iP!Ua0Y}0}cw=_fZ2OM#dOjC;J--%wTYfG0 zw){66-o+0M)s9H> zKK572TD2$FeSeejWUTP{lD{uRSw8uaT=PUV!pAxPZOOk6U&jtCdV$k!yO8kHHiUmS zUURliJv{2@M3Sr2q`aQ5UA*RNG85;u97JL!U!!Vj9k1ud%eUpn&hN+hIpp`_{8;$C zyhzVKSM)4?@6Vqb@N*)1EJXon2%LHKKVK4 z*ND#xQ9nO8rzmHZMB}yTJ~Cg=`Ml%%;lGji?}1|rO^T_9FRnPT!w35;(Rm2}+=frq zQ_rij@!S`&AMD*keHOGUmR=rH@R#pLe6V*D^&`>;J#Ir{+twk|-@^xcH{QRkizhiV zvpM;}Ayc?_+fcJP=^W@p9Jd_9yq@2G@q0H>obdhdZFxO^?#G|q@$n<_^D)4m?}_~U zxgWn?{5c`NMj}0b-pH?!s2~13lV3YgKO#MU{>iT?@8{1&c@4jg{Fy4R=hutZi`I+p zhi|*}=FfNojV2;H#iKd7zo0$&GrNYJyC$z2M9SMY$zEhYd>konD+C6UU3UhO@^;eJ z0c62PE~LEObp(?NwvX^RH!b-haRE*&@h0`(KEOU#Fww*m;IJKjBT3EYy2 zo5;<{i6L+Btg?zdGEyU3;JO@yBwU8-XB+wOu^SuM&PF& z`FKanEPUUs8}>f427j6~AM3h~$HVvM;kD0J;E_#w;L5FL;tfT=3T>toh}|BvBqF;n z+Y_gkd_qL_6XPmuS22l{x8b`=aOYM@lE{v46^geh0g}jeez8*eW{Ni!S>3n!Qri>X zV3FNAA7hR86D+j<$8lthtMYMF{=R%XmA@|^SLN>?5AY#3X-y)s);yRM_5vSh*OiE@ zRrmiDFV^@G<#l;~qZjsMPvI>|WTWgpCjD3piR_@wy@-9%K1pPwQ-_n0zeZq@ojQ6v znf9^>i|kHTE26sAAR;Tu3#(t07goP0FRXr1UReFYys+lY-^>qd{EKY)JScx(J`c*@ zm(PRp_o95T`v1SbJ(J_50p>Z?)Dq6LQXYXghkd=b^{MB{7e#AWqv&ZF;}t3j=u2{uZhf;%G-iF zl}P*?L`3%K_8;-%%i8G`M* zAH^ao%3G2D$h^kH%e4YgYuolI#d}h|#8zvK6RR!nFUhGu?oaWs{vR4*y|-FxJL|pG ziu|H_VfBmZh1D;r7goQhUReF2dSUg8>V?&xw2Y7&*WO@}z4TiH@+!@ai0m%g<2bTa zT_UoEs0!pn(`{H}v-{O1L$A!mB0J}KD-!#C6c*XXekQW=)*vjhcMtlL!Hz4i$fo3n zk^6PN$0GY+j6W%}e~Cp_gZ$72cDcg_G!TZscQBA$6msD!utB-(`UfP#1Snxx0;hpM z7szLr4;!Ec*h4tOa0r9FXeY{Gm;qVf40=dmm;&R#8@fXQ!ve^I+E5Q77)HP#kkKBr zgy9m%1|!%&FNVD!6}m!O7|C!XY=XLwj-nYx!%$d=_M>GCmq8?~LQf$WZ9?nNO!xw2 zqfnHAD#ARp8RenRU^BbsfGc>y8is3N1yqJ=(3fFf_yo41uh49Uvtb@|07pnQ8J>hU2!#P4Gn8Q;WI{UJWq21JfC&idj!e)UxxjulGt}5skxDQSYosb@#g$vM( zVKdYSy@!fu6vI&{79D^?V9(GVRY#BEA?O(DkSjV5n_&{1XIE2%&@l*O7=}JY2jM7u z#PB0j3l+hy;KI-a)kBwIC2~M3VLftVGgS+!Gpr6(;2K(Fyng>NBj52B0!{4Z|1?LqpIm*b9{zRz`NHE%HWz3!yHxvsWLo7H!Z8QQZp-QMK zs==@Zs*R>XL)3&}6V#mHK-3VeK;bA0O@T^~iFEKOQ~({j4Dbo^L0$~KpfkjQ2dazW zpf0M3dZ5mzHN)1ZCGtdlP&@qNnVLuSt z0l^LkU>E@YUmZBR*--uAPr1L zNyq`Fp^2yk%tTXBOGrbrP-{p*bJ4fxAX?0DFq`It literal 0 HcmV?d00001 diff --git a/07-model-loading/glad/glad.cpp b/07-model-loading/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/07-model-loading/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/07-model-loading/glad/glad.h b/07-model-loading/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/07-model-loading/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/07-model-loading/meson.build b/07-model-loading/meson.build new file mode 100644 index 0000000..b2de510 --- /dev/null +++ b/07-model-loading/meson.build @@ -0,0 +1,99 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +assimp = subproject('assimp').get_variable('assimp_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d, assimp +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', + 'src/physics.cpp', + 'src/mesh.cpp', + 'src/model.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/07-model-loading/resources/textures/awesomeface.png b/07-model-loading/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 zcmeFaby!u~+Q7S5EV>&cMY_AY1nEwtySrhLN{I@Bbg3YqfRyAy5D=B_M!LIe-O1kj zoWt4Y`#$fz&-qgxmJG*y$2;fvy)njoCsSiI)b3-U-$4g~Kv+tOa#|n|7-)h)sK~&N zL%*SO;0J=I)_ob!haQSG;4f%yiiVyb5C*}`2LY6xNeXnLcqysMqbx#5&@sURme1*c zE;28911|-8Cudawo zmjXEgh}BXe_L4?OnuacN$={H1<~FwEFz2T&ixe)^_%a0Up-c z0ctvy0gjf!R&Y_ z`kA|Na&vHT{!=qBPz+!qBI{vo?&a#C|DKEJ?&iGXk@hoXqfcvU94Pv zJ(G`KOZX>j|dmnEhT?S{!NFftChWt z|6e+IxY)V)*m-z$xOqf?Z!YfJI&Mk+T?b%KD|0XN|5sXW%l@TDjPnNaE$Dw(^oG~p z`hR5%E6ab{!p+;m=?{}zS#nxCSvy<1czFW$;Qn`eSXqkLxOzC7dr8JSylCap7=jv#o3wje~K|rFL@sz{Qe5( ze?#_WkTs*zZT`aAYOYgBll{LN z;LqNFx63~~^lx_juVqy)dz*hPrvDawH%I<6SKaiA0FDQMF#p5gK!*8`zJET)pf|mL=6!8oD`qVL@cet%t%?0{NW_|bH!;W04b1I-Jn}z| zH2hyj-a7JsV)+vmuptBXf}H={4F0<_|1;44%Z-0c>A$S_wz}UZxlQAj?ccb5iRiY# zZ(O%&{IdNU*Dn#>7Wj?pHjQ7lf8+WkqT2$$aowiz%l2o$#FwtwULC8FB`zj58B@yqsaT)#wgTi`dY+cbXJ z{*CLGh;9q~#&w&<0>5$Hrt!=6|A`CzU$0kM zy8!Q0`T{Rc#y}anffp}HZ(iKg{_C|8(BIw^{rj);p>)GTQnB$)eM^q z?mavWA%RFkpfsomtq{7?_&T(&hzy9#QqOl*>Y)9$kw?vN-?7{c(Ni%ZH|n1&*t0v2 zXYn{@cM>GrH4v)6fzYGoi!tcLP7G3+Iu~j<4Oj}-g6dvhyY1Ker%#Xn| zsI(x+&q?7v#8dG;6h-0)>gxPlw5`?ooG>h@H+%_y(1^2|!<^INOKq0N3{gP`m#7n7 zq8LDilm>4G-#z~-8#j>im^jZBKY}wz9apITDb)yq@3|Pn#s1FCEaX1)!|!pCZkaTb z2In=+AQbkB?$YgwOei7#asB2h9BwFXVzcs_as4Duhei7^8)H)vb04J3-^}i(H0`eA z99uKSJV5~`L>sdaOYCV%qSPPIQMthceYEw~>ZYq~+-CC13WvBxm|-+eK)8`KnqaYc z-eZfyC^vjWRXenT6k4Sx5Ij&gF76LIj_U(F5*RL-g_+%Rns zC=!D8s#-oX_P@YI3r7V>3xNa7h}}f-+d1V@NsB-n;Nu5Le{d5WfZh+gYe#haWfh}; zljxLn7x{&gB5>JXxRC5P2AmAHFt{0zH(OR(5~P~=VgQ&=h@uhTa!+^BXd#&r2yS>r zM>01MGuBBksu4%p-GN-N-($}$MLv8&M!Q27d$YW%d*?zO14tThwCNUwJK z>8Dj{KcF3QD7|GGl?hQ33y8?x^dgAzC&p)2c##zUg^{$J)SL8&$P->WJ>eOU!oyCs zs(k1)7B=T9kz1g>qnAf{F_!M|_1VSh5qb@=V1gc_LIif|q_Xb&tZ0U2Nbe&c=p9c+F;&*5!LiG!qeU&u)@ zWkwfE`p;43i5zdc-h@H;K3woLGCCisw98%@a=?5eE9vQ=-30xl8m>=C~q!| zi%RV+O?An!j<9{UtF<2WKhRFnZp47GLDHf6P#7YWJwD*DxIL@Ty_VT0{jbHv8|Vib zY|-x_zt$WOPkZqJ&1)xJ$|f6$XTGHfrA(i9hJ#Z`tZ%vhx-|TbIkBeZX^*qpX###B zN}MzS7IMy5AM?bn+o#-_u=ia`stH+HOM1upRa!N@9VEtgguTA@)QESFZCUIzGeRbU zWafHlA%Kg@d@@J=fJh8_*PJ8Y^s~1s*7A${+TmK(x5&ISFIKhJu9~#x6md2n&6c0h zdbKvIl#g^0?=Jb^Any#4Tr$8nJENm65bVjB=s;6xeA~&=TLtO@^jzN7bk56!|;EC>AK5rw1SoF@UDUjx_5CX zGkb>igjL8h+UCOSUlTFfa|AbFq-XXmD;#}uLJL$6Q!0!J<4Yn=9^15nf3O(|@qd!2 zr}J_DyR6e>KjD^4E++eEG$9o}z@amq>^<%5D?9E>cVfgO1#52aAOUU0WgasPG5JB9yne zOZd2eU$^$Yh)anO%f~oW$x8m7Nfz}Z{l)zdI3L%Y+;(HknVy`80W&^83%r?dP#nURnEMyx)1!^7*0jn7?ohqE zO^>a^$3d#t-K&9%PqO={xIwXx!gO*--2$0s{hrA0Y%Wy$9v_@V%Raxx^35e8PsgH2 z#wJ;;X37L#BC+SG%aL6t)7`V}-tL%6dzi)}LE?d*+l^N3qmw$C8lZ=Jd5F2{{meZ2 zi%^lP_0vg%{9Pb=HT}CdD;~11sX6}2QoIHJv6EgpaqDQRh z$@n0K;!e&7_UYn@+~EY4dq${-%3AWuGRZ_J$l}``tYt7*&I<9%{h5#76p6uDEn>Mk z0fs<25}iWJl!eq?3~I;!5PeUcnq}PjjC=f06%? z0V~EDzW4l6CK4T?K#c&bAilKW=(pcKEp{~T;;=#ad=cvt5O<=kp>4V`{G^n%aMAwuMFN|w69Tii7Y4(m)J9AX0126F$!aZ0fYHxd-u1=63` zRbxJ2}Sut-dikP zOc*XJ6@m`?ce7}u>TloLdN&t$5?z+0tPKJo*sf@e2vaPS%s|58d;lGVzIJK@@|;hoD6C3**-`i8K_)s6{NV)9y~oc-r3!JzLSEx*8Qo zH*OngzFATDa%Ds`A<#ZyQmC#Ji}~t4=eJ6?4J^dE&HR~X4$)V7?EZ;zM;NW@k)TIJ zZ5d>`7!xX2oa+ z^5Sm#Xj9yY1w5%J3Je34paVntlS^xYGL9LN4>^7)8ruiRz}74hmkZ~V064#-zZOU6 z#h}}HVs{in1MzrS>Rkp@N&+woIyxakI9PdR?ECadNc%+DdaEvkub>_2tEM#I-neI^ zUm1UxTtBQ_sDrDw30=_6c23wPB{zk;mHO!tCQ;Qhgm-tra>l!yL&v04Pw5F*5GSB( zEg@^4zDjed;^Mu6^4p<>w0=7^z1Wy(yuL)k%$Oo#F|N{usXaYHYpvkyCEP96u)VKI z7_GMUt!#zR!Z*P1!rH)kO%>6}jz|Fp!B$*}0pWsW@9r``3-_7gWFzIFNzl)^)4L>y z-SPT9#=f@h_y$R&RDpKOn*2M*dmNpuhr9t?mQKWh-<^|F9;?#k@l{1iSN7E~NG3mx z10^u4;*MmZiaj9RI@t&d+@Wag9>szl3XM6w%)AQ6WocxIRSTP^D-ZOWuXsPTSC~NI zfL^k7LTPs&!l?WhxRlEU>8e;0^M!qC-yo9gOIZIQk4a|6t2&oNS7zvkZF_-c{853n8 z)MSTnCeWJafRhZA;4}11zZa{$L^|mBd{) z;&Lh>rYw4}RNrchj}-$O?NwRxCqdU{zL>@^GK~qkvkRoVFN932N_w7JaJvmm;WJ>W z+AgF%77-2WGskmdDMwHur2|WuF&UA~stI0`#V9-qau5@o5~gV1k{0iyMGJ=9ebI#Q z-i5FvY5w`RiTfk8?jvl8*}ivckvMVCG`pop*t4hj2)HHj2-!F&3zES>0y{ANm(LlA zTbmi)`z1oo(PS0_5r^7lK=%fhUvj;^kDv3QxOKvRDSEI^P3Q>110@>JqywqCa-z$rBZk!Z%Ed8)rkP)&MzO;KL>;PcF5oZ_vC6B}Hghtmk?tOKh)!7H z!N8#vScw)a2l|3Oil9H(WqYZ9C#P+o_N~WMWYE~;ll9%N#iqCx?c{xnautE30`JK& z)Ou_O^}RPs?6#cnxG4OzMHC@YRUS>QN3-ub;3Kn#wm&f#pS>b}Y&25(9+Qw8xNdFQ zmiIEjJjBZ?mP^erIcFCV?AncBk3j zO>rZ~WTgqNy|D?CvXfR$tfbs&cVM9)+m%f;D=@K@s1!ts@D6-KWbpKaU2VR=x6r-y zUAs|oXo+z=j0QDbFjo}=cT=!})wYLeF3!7pvur(i=n9_zh>iGAnl#A*R^?gYn9P}X z<%LT5mq^m5&jqCrIGMbiUmqzg%^xV2kBAsl=4tbw#-idP;1Xq`URLlXz;{ALp`F>H z2;%4tb*eYRgu+pG*)i8CnQX)dms9&#MV|`JPS2862LXN|R5foGjtYHZfw?PZdk3CM zMg6_HHUXMWJS2ib`eh#@+>H=>1=G%(+wFn=a`vn5-(Knt@kNRyxG`u%T453*;F`xH zXUi+^6YP6l*R9z|1Rc<+8TMfu3+B~yg#dG;+(TwEvi^K7@DbV8qpQ)PCRn?-Mtr0P z7ePEsyv1dW6c6-MjdM;{gt={YH{@NZQ2=^VVsF@hf=(IB#Z@@X>0K~z8}y7)HdScZ zv=5_w+2Slc9T?pfHZ1khD;^c}%a*4O*Ek(T!hr7AJn zF&KYrOV2j?%>>y}&-8_$vvQI9k=wmcLo4kec$!65B{G_2aajiYB#0v+j6ES%^z!}u zJ_+P*`CmD`@@z2TN9GClMX_vvPC2FEgTPsHEss4<0`Op*}vo0JD#AE_Q_eY%8dn zOPAKLeu>{4P7{fo7(2j@w&~I%?kmjMq)X+1XND9lRpd*Xj}wC+BruXUT!sB^Pml$j z`q~w}GIUry?yy$*HNg1pyjwF=?w%*dYE0qh&)=%6^8y0WU5`Qqc9XrLQK3B+WJZw= zN=(%07To2VTS=snC6Hr*+yJ@(z<f@EZH=5q1`uA3Sd%3a!3Vv%iIvlUFqOxG}hv3T+bwIuB}h45q-EAqK% zbru{kT)QX`3o*O!o?X;rg6B~H|E+z{H9C3*J% z(!c;53S9xcV6u-6;d*mAb6B%ENO&Lw#zpB+OXN3|7HiC}cz+bV>9znO2h|mC?l9L+ zEb~)tWc|a0(#a{@SjNILOt`R}{Me$OnJ8Y|fW&fsU7AeIj^y$uFTJu?G0ffZMm9t@ zjsP(rM5^vW!*UkeAF%3?c;i@fa<}5WTPufi9}kMaCfB9 z4DFjBBl&we2AJ2av=m_;O|x%yxA|SE$ujTt{4pS( zFAv4`hGF3+1T|WTOnWTIGJ|bE5w8j4K&Rgkr5+T;!=c+srRP@2Z!wcdL#1)^??aM} zlsHtZjvg02OSeNEP6A43;rMTW0ba>6IpLUH&7tleqSPhC$UIYphO~gBN+Xwqs-fX4 zm?TJ(WL>6?rMtXuk%RgSB25btiKIG(;%;4#tQZ-K~4F5T5$|9=m@~0p~dYj>51xh%R=i@eyW47A<|E5(kTx~O{Hq2 zmjE}C-TR`F+kSH4u?E5e!M+5yn8`fb>~zvFxVrW_kMEJ4o@QFQLF_` znmwVX_W?(V?57G1i66Dyv!|!#si=4EitoVAyWhnNzZYH4MrK}NMU~l{)75;T+DD&_ zG&r*WqmHJF3MHF^AcI`iAXwvW*H7O>+RcXc!#a4DtEe=VOV$|yujAG0Ol2=0?<#Rs zv;L8Ls3CUbrZHzbfItfh`GHOohP!zo8FZqt{73=>q|D+cI0`pQN?ER6ZJ2cDi+0B6 z8Rpn8Q56+lKw?0rRQJL*HAvycoEvTYz6p`&ti^-(fNe+QSbJ{ncJ&LLS6>+8)LRMD zg^Jpg!qML#%7I9sE2v=`q1#GlmuGwKZeL?3mQ#WOYeFKhz10btIu{Q{DhXtdbO?4o zj7bV3l}F=JoRJ5ch)@T4p^u3dd1J?%0)_NbVx%|Y(p`~YEfW`s(<+uR92Hs7JATBw zRjAOhMJKa6(h~crv-D4^zuTHU;LfA6dszusA62pnKG6kgi0dyT@-*|LB(LRO7sfnlJ#ws9%k@p92#Jcu22T^ zAJw^3PIy3?2%p12FY>|RtJ>WiBoJy2H7d_Bh)=;fM#Ka4KPEe+l=iujyhz2vd^Lbo ztrHG7JnqwO5oV(q!h+VoxVO)e%}}FInP?%yW^IbL?GVQ>j?X4nrfx=f7_*tkDDR7~ zUHgpm`k5!1jzqXNT5=H!@{#To7uST^2*rNT)^+p${64%5QH|42cemIm7%csyUA{1% zENf>u^-+dp0A+6YeWb@ECRA?kCd6I{69fU)QMyA7w`F9^K2R#p(Th%@v&%(=uA0&A z%5mw#gJYA%YV5I#az|>A_*T`q*IF!~boWRx=X@L$8roHjn<8v7FiN@;zHhag_5Jh; zu&cT9s8)`UzRNx?XAvI8v1W6)X7fZ)D)SLJK0Ak~G=GP-o7F+DXLzAu7Up-aN+|C$8VBdcF+AFBq(W^z*(?ii z61JC!oo61^M{Q$ETi^r_t@W_=YBlS775uGP6B5)M);EVngx%^JL9gOPcm{vGE=>Qb zD5(9)HqX}`-~Wsl`A8+t)*WBTpV)ajoFSh)Yi{>R>YTw|F%vU`A}_c5qJ>_FKhv1{ z6hbCslK=s?E(m!MGI$ExJ$arP*oHeKeso=S*~Ajt4iYBbYSOf^9$w)OI<=>F6d2kY z7R0Kms+XN`TO+gS!0NU-{vp$W+51`_rlXiJswYzIq?3k;oH(U;xeNeX4Ulh{*!G#gZL>{UzVCEH zBf2SPPxPfVb)Bo9QQ>&MXS@0oJ~}Je5=c#HH5-<)OGXzERUykO5aG=I%F%siX zx=+BrBj=q#?0CtNNa|v!3n1E@S_rvcvS-DoXPGePm?cd zAfJTo?CjN@AK<%FR_&iK)*O7*o_ts85cgG~M^VsoPnh1s&&KyWzN`O{4bl6Fkiy3A zk!FqMIz;&K&nR)E+ES2H*h=Q!TNAN8)RYg7xJTQ3KXIOJ`N!tBvx9nGGp`gMkHUPS zYE_=cR77R22-f|)R=eau)%S|LgT4WKm`GIUR~jq>0+j`Lq2q;TCp_Uk`$kLb^!t3T zYN&KCjQT8EQt}WBcrKIwwx3g?HZtSGs&W~3U7uAd+Y=cx{R{MGWGG5DLl4N~B*nhM zXP8&AaIgnRr<&$+d9S{Rafp^N7Umd1-nnZ`hdX%2;0jGx6yN7rG94PQJhTwY&Q&nn z23;eFae!$q4IigW3Nw9x-woCpFW>WWhJP6MKa`PtMATjs0W6}&{O)Jfj($t;_lq)< zkdZ#rSK*w@2)v4HC1e+9<@g*P4vRJ&o@x>%e!{D9=1qw~@^XKQ_08rOWiaz(XZ&ib zcj~dtOr`}pN6`R7wOmM-pTF+v^PbiV*kY^kD9VMqXrBk-r~G290w)y}P&Vesx~XPv z(3ZUyWlD^ZgZMf6=$3p}d_I>VCYPX$-vO*{MGe-Hzi0noS zU4bfgWk2-^zp8_ho^Ivn?X6ad`Y$huSB;Bn!jB#wsxOR?BlEaE;-ygFp9zVq;b&DmxyYpSV45Jgqyq|H8I4%tq(2A7W%dW1nU<5v={|NN=&< zX^gYj(WOfx_ZUS|hmGefWdxaUlj8Sw&EZ%Une)efI>|v8?7Gf`m?2pm%efqVz93$x zI4!6(@g$fPo=XZRQ1JSh#9t`mOzu#!@|Ar>R})i&>4EuZ>Tss-&j%we9}>sU(q5R& zJ-@i`HZzQv+ZASHIeLr^`Ps?2&&O+JP&A>_Moo1d-I+5A@?2t4;<}hn{$bP%FQ+b`q+s# zrKz(k=19^&5ExWtz`F;EM3ct4yjXcCTQ|SG5ITOeqgj1*twV4!^)Xu%{!xixIgzwq zGGWv-OGO&)H8ilidM7MAl(ja~Pm!P!pI;eD~HO%O95`6p~!9J?hn^y*x>x2qw8^}vo`{1~rx{~r;1}FTUZSObyA1tdh zbSd%f9ZGg`FZ{q48j77*O=b^k3;#&>ayago%jLTBbC6b=IwX?~oO>`1dX4OO6l!+0 zwusX`q*p2_*fsSiIiF5URZT4i&b`A{hPjs7`{T#!PoG|GZaSf(qpuFU!LX?$OT14| z7@I$L6!5O3q#!?ke$sSlDa)5o6XkLz4edvBc^L$yV_sS0;rH;f8#%4i;x;H=4oL)xA;s_HFdQfL3vF z@mQrT&e2g`!cpDcw~))N&(9}pCu~In$aW2+3UdkHc#L1-_<3j=mN$X!fgI@s^mIh68RW6jn7)I5x;s2x$cN;(io*jPenth36W5=Ro}xNg)=rDpmu! z3U^;vIDcJk-{w?aUtMY<>B3watCgwfDNnAgZrEDS{+ah$Jm7F{NL$@{`A1qjwIo$R zKk2UR<}57dWHvNMa5gAu>3izn2ywdZcqLB4y#6RwG@>dkIR9l^=S6*?R^9t--d@w5 zZ@7@NwW9!qM5^xBN=c*wPNW6*6B$@pS?Nsc>g&_#l~Z;HlsPNB)&_DVN|+e41+PV; z?k*hAbIg_Zu_;-eDT}`H+TJ${M0krBC=ZIv4h*YAeX$X`Fv-a6XM?xC{WhomdYa{d zJO1&yUUYnL#@13zZqVl>b%`_#&c3JS*tuut;YF#?G_Da~3p)e;zgn&UM_kJQ( z)(oUXzij#XVrM1GcLr^OH@+o*h0$ZeKiJ9`%hda8D`8Le9u+67R`S&&Xn@%#RA^s5 zVhujsD4gCi&flS*Z>R~&=%|^R9R2~#&v+_6{SfteOlkYYaaKI^m;&IofgMSb?*jjM>Dt z^g79~9+4A{!teQF-hD@hSY5pJc->I98ttXU@;uV_Q{dklm&y?hx%3loo%vC>l0CVG zWnygn9e`q3Wv8i_6S$xDeeBE-=|N(0PAuo$)_53#2Y%hoGQUaSN@^H2D`U=&_2Cl3 zMnCSsx2hNy40Z793oeP}*+pbA*cQ}aK*Us9svRY&G&n<(D9ll9_aIeq|{v_wPmQsajDFQ`anpsaVRNt8Sqqgp<-iF|9zAyND+m- zmKOd_(+QPrrn|xz-!>X!ChidE&GE;w;)I$Ab`|kTlGyHdb;xpvk#&10@`Y07EWP68 z&mFfXaLbK>4B6Fqbv*eaQ5y;=5Rh6T#+B5Q^S4HQwZ-lBprypEDg69k$oFgxg1JZ zo(pSi6azfHZTII-&w$0tgWi>E zPHc;R7gflq`ORlwaPVHSFjeT~-m`|Q#4pCmI6NQkgT)yMrJBT#AyDwx)M}j8YTE0S z;W#5E*SjKIuV^6ftLx&B%b)#dlI+I|!zS<@vFewGsUOh4R-PZOwGF&c zW@chS&4>nd;Nr&_%gW}P(J{1 z4g_P7?|Q-?^8CqdH$&dRuAQ+JM@HNu*%>oe&^J@{S6pH3aU@AE zUf{cT=M}R|H~88D0cCzN{!vSHb4n;98K@LD32=QGv)V6anob&TYJ8EMG>bK&{SDgL zr#19g{J97E95sY_A5LA1DU+IWdGMiv5Tkaw=`KwN3`p!j=WB)L)|b*4TIl)cA--a$QgJn4#~ynv%IxN0?$ znHcoudv}E|k5pmHBUbt(^iO^+?&aB9m?m^o(3aTbT&t^%!Fy@W8OzY_qqgBU#lS|a z-1X{iY)4b@k6yr3W2?qb~L zec~*#eDTn;n_uj5w+(NS>gCIqi%UyUS1XM{(!SS6-*kk=;@5XOQuMo1@AlQhq8iOz z%^bZ^zGLj#&e`vQC`3bXM%LkZ#>mp)Xv61i7Lu`QC=7^#v+!YV$u^6Ma;Nc+<(L-e zsSA&{eumGM_MbD%Kyi`%bePm^+AgdSxUU6g{4C|jL!ql3^^Vd~K8I7E5h=fe&KUpthldTT!zKE1-P8J16kWgqU9j!)4BFE3NZz`=Ktzo2I5Yu~zf(_m zf4!t^`T2dSm{o>%@7~=N6&1~wIM~+ZUE^jz@mBYA>SiQLCM59F-A8FwkoVSL$=L?E z$YMMq!GY$OPyu&Ev!Q~hKahuVGSPHDTP@CXJ{2dJ8B~{~OzEID``H?WC+J#s+NL0e z@}BA8JRMaouRfLnC0)DwI8jOB_$jABIn8{6WDAh~NZfP$m;G6DyAxiJkr?lR(2ZJr zQz2BJgzXCX0}ANhW4Jz6d==VUg4$XE>zCyv<*g;BD8I6jH0-L@sGkR6z-v#&Bu;hp z-S^r_9y_-I!BGO7n>;;p%I75Y89wJ@1QCox^r)`JgG1u%bJKC|X$K%tH|~F9)$C_` z&IGDSH9XsTS#p;jyFEAVy?d#C?zfJ#)MIP2om`~M^e}T;(4{51QQ8LdAeB53G2&54 z+Lf$1>K+4?zYEEX`_x#I(bM(bj)iY8#EGxZ53!GfAE6&+s1hAH(T*nfz(gw^w z3Z4w$TI1KR!sQ_>z{c-33D~-GCp~e?Zu14b^4G6lpTzpa9G+Fp2|BvzPHKF#bYcY} z4S_YOm)-oZFE_s3f(C7s0i0`jsK8o5dP=mI&>6N@SQ4s3!~3*XvczTw0p80y3)t*% zW0bSB^C}vPoHk&l`AUg?;}L5_E8QMA5*ZvCXXlh2bbS}9R_GrUv4Vs;c{Sp;wMBv|vpf4LFYW%+#eIas&J@Og z7AV40$i$-1NqR3McC1GCE*KN+aFQ36%G3CsH7FEIpldmZEj#s0Lz zSMcC$6P*rQ_#~FRQiX1`F)&H;g%xkxZ?8(t{1LQ*U~-_U2o;*Nn+4!!dWdAh367n$ zildR=MnOc#EWDk>6!T(l8@QDMb{nVu4c8k1DVMf5i}bN1G^=2#s8YFXzg=>l)XB@{ zgnXvU6Bs<9e)(N#X?*OC`}R?eY$XAGH-&bglg?ulOc5${7d9ya>`OO7kSns~k>u;p zJB&SB*hK7-IZ7P7Ps>I|v}$1OWf!JC6A}_Mx!prgM$7WLnIA#T z%B~x}41O#Oo4wlF0A?G<*{rCir>DcOZfs1Bg@vWL_wXBbm0NF?sg#0@Q`X0R=JMWe zEo4!dLIO;66tQ9XZdJ8EkHat}aHLxF;l2-tN$^#RoF!GSia?}TjZKZMWr4uG()IZ$ zOyP?`?c|nFR!`BZ+SyH~`G~ehAl*igv^J>AeagRA-@y1%JwwE@1G7isVzbDRGNW4o zxR)9V%4wjQmKjdfedZd&+?&3>4@UPjrK~z-Coq3S$u$LO*#dR}Buk8L6X8@E!I8r- zO_T)Z#)FDb@Eou^qX+)mDO%+EVTX2`O8M?DO;_;d{zeeP9vEVMl#?UXKJkFc=+j`R zt}E9rus^tOO~4!*o-fxMFuoD>-NgvSMi!XzUOPBG>*0@2cn`yukWd@GaQz%8vsa{@(b$5E@pil>Ku{oMUR2b#cPVDzSqDz?Sphr~@nF9ILOklUrFeLBHd|z{@_7w^U;bvoaLF>{FQpi?m73^PUC@Eyn^KyOpnTO3eB8a z@ynkT?~Rb|M=T9upIzdD8UZ;y{0H zH}}<1#S&6cxkqcJ3&p4)KdCwwf;ka0m741hMzrt?`1-*EE-&S%j-1&Oy+d?Av7k>M z7oP6{8Q#QuSQn4KBPl6KNm)6r*uTL`mp?E?SLTDf0|er9hVzB2Zl&K+bpH4UZ?Bv; zFIj>@Y;0`)cHsM~;-{Q5lQ?G;FWt4B52V6lL^*cI<0q*l@JUHHW(7?k(5_J~1aJ5T zVbli4IuiTSdy`QR#BCndoYJ*Vpie-eS;V-?@d<=ODA4tUscl#(eUU`gO4w{n68?0RvWA~WBkWM-)SOV)s&Yn+gJMw3icbsuV#5Bd<4Fv z*s3C|Qy84T_T0PN{_Gcyh8j2b$_*FPiwik{W04#o$Ds|c3GatK;OR4Qu)ca*k3HQ` zUj7V?fI)8al#16zMW<&H%lOXNo;{IOd)(cVlWE(5i0Sr--t*9H_;Q9TgM>uQx!LvQ zndVtjsQ^h?V+F~81sgXmw5u8%Ob^~zO~T@2_WTF*y77RE-0;+}blHOM=L4`;KzMu)F$j*?p;{(X zf-)8=Tx`nCV&+>>6R{1K2tJpS>(420pYdOjUwX|xJ=$tpQk<(yA%jw}npYpCKQq2^ z!v3LQyZ)7PvmLAFWpH+&W7)D{9KXEDa4TA&*BfJL8LsSSs9p|QDLsTBCtMlv~J!MFLszW`8n&~y5q{;hf2L`_`%B*q?4Z_8)&i~S7 z4?Tvh>GY8sG?upR7@GhEJMP)|{`8AEGhK34eH|G+6DKssEU1R%znKr6HHJ+QtOO~2I0?e7|$Bp3C9?=5uRpPu7jV_O{7H^utiJ5pH) zf5|Ip^bm<1o3Kd-Rcw8onr7zfMM?2xbLZJg4kwoX>6_xg3ahRc<)Xwwc6~J2LHkPA zS398>-oe)IvwBB|zGMTzUTmDk!=H1x38gk-MMmyO2YpHfHNXRj7`ZKidio>aApCf~ z&024vG5Z?_5N=-S&FK|CnIh23S<8D&WwA9;9byWzk)<5bVx@~AnOk*5K+1H{D=j(N z*hfG_?yGe*weQ^NFEf>#358#kpNY}a(*wlS8hl8;rSJs8JT%V?kW_m?v<1`M!3rPj5fmGd#@MdIXyu^gu<$3fP@%inh4Iu8zx< zX3tAZuVOboG&}`%%^dZsw6JY+XZOnW@3PNm+rys5wnHzZFmi(Zzm|P3IJ&&3;BlVd zdla};tp=xPi^j6NIzN(RLcAV@o$Ehy>Dp&0s+DDXJLyv|3_r|G4iP{IjUhtd3ZwZ1 z?-hQ-Dm1-?p~1f{(l|N}3k}uM(#j7Angwb!S&v{>=Nn}!$h*O=T?B*1Iy#h zamwb|4t6YxsTow}j9{b23R)0&`Q(a)W+J8{vIvesuaewx5SukY! zaw*-jR&@j}?{yvfHlJs}T2)fk{LQhfiTKb;+H*Mp%TLpBuJ)L2& z@Islxe6q&*rX+(<=08*IsQ&?W9Z=&u*PSzxJJh|Ee?8Y6nSVV zerDN>$U2jgH{0)SoOdNLD&O;g3VSY>2OK%f1fM)y?#)pL+(T+RBQx^{eX2?8%`=HA zJ3M;&t?wqjK&i;*)DZaf0cmGrCx(e)&pu~4lBbd!Op~B{qOyaLFKWZCA#NCEZZI8z z5D|<`pdJMp=pNd3qV>IbKzn>q?z1zann)#XalTaTy`cvz7?dfTraeFrJ+|A%@uXUz z;Q9Q#1%q1VSLVXZRwc%)$aV|+lOw??w>I?}l!-RpQ1Y%QL2MazN14;Kvu6(Z@1_)v zzt*}5HBmM*9GV4y~XEUyef7sx&cQk6M4g4ag0nPoo}>G%%?bmr!c2p$x5Ngi%WQkEQ?SY4@$s0z4)clk z`O(IGSjg3NlQd`;DYHMgnDJh}d#1P=gz>}(r zouxFNv#Du`mAF1yt5=$Kz-)W7EiMzE1C_-dp#{vF4~POArMkMh zs;0(*Ck-g0ziDo!%2M+jsh@UXBgO#AVT|HeWBPe@b#=h%8LeBQSAB7(toY+~2C^FE z|3lMPhPBZ)ZEu3RyHljNQ(THW#kIH=hvJd~h2j)1Qmhn8ad$#-cXxMp|8hUa_vUAk zot>HM+?jK(o!QO8sAK@}5f(CsvUIS~L8jml5M`V!C|(L%@pVLq2Fs}IrZ+zg{YZ3f zBG(4yHgnECpNrGP^z?yH6ukF@tO9OZ@^0?#unO^L?6aXK|Ci;`tk1XKz;})J6`#t7 zPsMP+QS%O%K9U8Rs)7YlU|=n3_&W2TI-HBK8rqekz4x>rm9$cZUSUgpM+|JqKl2ot=f3_g0v78Jy) zVl6sWc!68B7GXKfL4szt^3j|{QwY~}&K~`BD7Y~FG_=j(e0${8z_fUp4eYJ9x7V2A zb9(Hli z4o8r1aw=<~{|5x=WIB3cAr&ufyHIEy}dl%XKR?o zny|6aHn)rvENa3(^*kQ73Uv)PegFN||8 zG;DV6nbtlxBdf0qM+?EGp?Ue6-%nt@zuOpf9jSUQ&Dk@ro(Ti%Whs*+#`F`r@YsXj zYkcIv2SWimq?%&_0Usm&IiUtOu0w&TwY{^-WC^Q7+*pbrFgMn;Fg6i%wAI>!cizam zl_Dra=_9PaBU_;GIk^BUcYT}_Z_4n#*APF z8h%Z0iaqt}>FpgPqg6g*q|EO>02h+UaL}$H?GYRZ3x)eXX&hM7T->?VLT}Wy7ZLdj z2@MIN8d~EWtS9y$&htcYqWLlae2d=Q6`mXQeDuMU$KB%0%xC|09zj9<6>PKj=H}+% z<$pf8NJNoI15cqlgsCR8R+g6Xo85OU#U+(ei7eI#5Y(JvWl92ku1sZQ-0QE30K7-1 z%S0dRnYU0|`QNwX_InM$nYYMA7&6{dL~n(#$eIQ{<{INA$iQ%k<`9X-e_x&r(m6FV z?^@ev@ffNS60(W(+bjahoA(zAvhUAhb!14W#0o3V@X(&wkFmAv!>YQr&DjV5nd&J* z#JR4i=KY5a&|L&zTlKIDI_tG!l_pZrA&TMmI&uO5b4GMmie~@Lje}ip-D!;hI>7Zy z%lh2m;L?Z z)^$S&NJM3rJx>IG$D+nWJ|MX=yBO#IRic*kqM?zf?g;g}Q&vS)bHXnWV_6xc2xb@b>cEl|81ln3}7vUqGV7BP#4;>$fL z6!EApT(@y9 z2YmBm^)D(fKRx5qC$Sa;d&55s!%_S7jKgk`f93sGY3h|2kEizfk*TA>Z;aU)K@-?Q zy08v;_$?W!fYxx<`{Ji{7j!cstXP&ma+`fX{+rP*!8)nhQmJk`(>->Mn2hnLyX(5D zgzCu9)Qo5amvWvJjkV+pLbMN}g$q=&?z^MDTT+Q_%!Dm(et)HV!|lvte(zD0K#|`G z#pl~6vE4oL$IM3Ua!GY(=};DS)L`@523Jurkc!txHJ9yQDd#2OhS zdI6c4s)HFJXwu}CisA2hKr^!swq>_cvha{B{0srvx1vHqLXpK@xTp<(O4(PK4L`hv z@@DlRm_C~MGQ&ekcY@*!E6pW;c_Tr^k6(pOv301sh5C?3GIdaM8)+nrEvQY!U@pKOpE(3ZeTc4&+@%1uWL;LkIlhm}#*@I^z)`&7 z5s-_-5TFOjpgqVCdNkTG?6fCQrty2T!82AG((mh?v#HQ;@%!~%k?s*>yVTLk6QrU|T%aKIqBT{(NCUIf? z^lPvlodmQT_;0fLN6XFioaX}K;J~;vrd9h~LX!HHpx404Xcc$R*bHtkGlxORCm&V} z$#*P-f*N8gIC2uHQjQA;K!g7W_!_}`WhcDKbaw-^NAC#fytTwaQ}N^DV}x+fh~r?! zW*2bAV5<@kQ(q*P*l*ckuKZTi*Vi|)4V)&*LkD+f1BQkF%nD$rcjwb*Mg)nNWkQG* zTJdpXCm)}53#*}?w>doy5S|TVrua`o3HLbiyOw7wT7U$np1+yo_RiUL#V3A5PeU6LiC0o%ebLQ7+~nc+HIA+k8wwwr>Ext zy7-X8Ld~C?b}WP?)*prl3K4+!-*-9zD(8QC>YbLEE%bIA<|=acY=}nVBvj#{+28ro zPNM;rUkngD@S2t|S;i!3UI8CGlf{Ii9Yz{MFQtA1fbG7!zWbHvwpqHBMY@F`GSOM24;G~-rp)2eb&|7vD;0$ z1(W|(UNWM>L7r*9>p1CPiJ3${>cBwU-H_ruuBf_Mk`Z3wZ&nOjreQMHX4N6ZPtKwY zs`a!tsAPkpem8wvV$mXxN7V?<{BrE2pn4V)r1y79+=Oh`f!0$5jNrWSB0bPR8mvJE zFGe=X*KhR*o>3?*E@1+(nKkJ5lrm3c0h~@AuET@YL|1kG?B?qF%#c zguW__1b>U0Ny))0&DNX9xR&;-^OYF-H2BWuRAe&K^*!8bQ}c6tHZc{I4eWMwruRmK z?T;(XFpWqp=I#(IF}*oy50+R14LAj^4{gVG1vJp7d2I(rjlG3VY}RzjHIVp*723YPrq} z169GgFNL#I4?PpJvy920!O%qAcM|T{O&i?A&Yum&?(MANH0&bzGKf+F9-!>_{3m&C(E|=7XqYoMLGrpS;uJ5cs*7Es- z>6c|2Aj^aX7&=n&WPl+d5k_H}L!!A6)oM-&3WhY^qLG)X_5VM>if159wFolnmu zY>6G%D=A7NnJ5Nt+G?E{0bVU1_e@5bllOREVT zWJZcfiNWumIT>zW5lR=<>FSr;c-wd2*HwzjuU&WgRXAC9Uh7x&c)g7hi>uEGhmdrV zivbr4cifzvu$*dZBZTN*4L8L;Q_?Nmt}GCiQRfh5@dfP1Aj#8`arBcEPVvWw2pE_$ zV0V9b&e@BI{S?v2e)D8Nk_gP zt=Q$hY)v8w&Dpp|++V#69Qsb*kf?6EJJ0s8z85UQZl8$*)cGDRFaZv)b-6jhLD?Hy z{YVJ=E zOgkHG_z+4)gSzY3kr6f9PY3y?P!+l(S0f+?(nfcwGkqB|NTFYSa#`tZgMdVsv zU%Ek$?o5h$-#0t;q9=m7XYYQw#d(dru93}z(s>X6k3vA$2dz{?oG-cB z0V3k$x`PY*egNC?gYKrDf#V`+oqKAQ#qK+YqT6lJrdokqWSFdNnYVkM#deG2C&&0e z-Hyq1gR%JwYzz>4U=n$4X`atUSIQF=Fg&J6p=bPWmM~YOUyw+{X>oi`6{P+~yzxJ6 zjz6%6$x-}Om@tY2OTdQWu;Iy@!D(s{4?t4q8p?kPU&;cz{&N$PP%t&>fB$%^wsbOa zYtEq$8dE0%6cAWpswC0u*D!%|^uU4j-f#a?%}S=t`*-)4ZQYjmr+%l(-v!%*|2tL* zcI<03JqwUT2l}6dH0e4SGmR%EO5+cT&y<<+m~`1imfYvspwKiN#K^ z5d#0&=FbXXh5 z`bCcQf5tT;1H=@=0@F=BJ#zxWUb8jJtGuM|y1@T)H5NND>E|J^>HO1&W8s>`XO-|? z?gV7{{~*AEF!nCVv-mu^HGAqK$n>ue3FWXn<^QxPAtrGj0*@INgQ5R+A|U}GcK?5A zazs!y1jA&>FF|wq#b5wBv(+0Avi~HP(b7bMdmoPF2)bop^BXq zW9D|XW^$ju%UfRfrSe24RRMFDnRdDsFm1lIe!yDeLXxp1K#;_r9WjhT_}QjXaIO|s zxZe4guk+{wV^eD7r>Q9H$nU$)Z%tN)(xYthMNl0hldEl8D18yhg-fj~Dlvh%Q+NT( z+jnAPiJ?%l8}Jn2db}J%JvA~xzvkhiV1pT84R6WG5TZeToC_1DN|Rrr>SwcNi!U&m6gJHC1?!4V(y$7I7ECSBrxv&j z%4gD&*eHwA1SCd&HIH(EOdly~@FE}%*O0ksoRAVGITsl0kmeiT4WxVy7{kYBk@(R3 zCpbxAw<8p<)C&k={S1P@3X;|=S9wz0pR};SS4L@x1-drSndse$EljY>UIH4g@Q-|bF$%N)obhpHrV6A2|1dCyi-YnZW6kRp6 z3^YQARZ-OvMg>b9V(y)(*9MZrHz_k?OW4$je6B>q34891#4)?_RI#J%Flp3rVw1gv z7C-!%JUbIWKD((RJuYF(6tViiPgWujz|RP$SfKK8m1sNEs+RL-*2SvMEnVZ)zxgAP zy6?)rkwKjA{@IA%)2`n4v+KWwg;f!bR{kOA2v>T_4AeyyaVrbCX@5_ZllNdw@3ZiD zktTS}$CQvi83A!_LTm&@m*V%FRw<3m2Vs^>HF>Qf>awT`Q%^m@2w32kUE zxsxRxkdIjNqCK*B{8?lnj>KuC3SN_36Y?Y2N3PFcP~5)VWRhX3DTt~QDPKwOPXbpQtdC#(uj*4h*ruoDbffO?-zB zIUEtFP2)`GCccIU@jP>FgIu6BJ$uPQcqk`-FPqaM-^kgE01u&dr~D5US*1xm6MuOX zMKW6iLURx{{JQ!o8KKHgW*sC0ACb1gwcT6Kp7~~rq_2#8lFamQ4=K$>!Ik8~H_^i5 zzDSsYfDjXa?hp$vU!cO@D%Rs8HwyXAEsSErdhn@L#>6B#!%o@pdm;-Arl{0TR{A6k z?1}&&ayfvFHu~c$oWdS+I5US-bI;}a!N{3mA*m;K#mWsywcVqw&+nq4w4oBLF)d5; zn1!+AJgGSD5)h*L9qU|Til4)nHxGTZ&;aOR(8g{*`lSl&}fRc`#bb!N& z60uV{+0bsSL_u2$($lo@1mNmmrj|&+6zPJ}9^JS}=lm(!HCYe=hwS_3k*#x#LuQ9} zDDqXWIaOCsDvscxou2O+%r-g6l_e^M81l^|yOcgDRTTAF=pd#xY@ot$iYjl2sPx1W z>Dv}yk`(for+%E=;r|yTd$|zH)f*e98tBi60HtguJK9&Pe7@!?x=GGfL~lqFZ!RwC z&DSA?Q=)@qSp>ZLs-er7i7lq5XA9!=7-3nOqwin*tDjd-!*Y4co!q;?W1tp|GB6Zp zvOCI9mRjA~erjUvnzNiu3$|BK{fiZ@-mO0p4?ed-#mG>r8IJX8n&A2=Y*zMS+UXbR zp$YBOiog1EWK2;{?5r!~Ob*Wp;m;YX6-7kv1EBi_t` zO3RO~y1=G&SVJ-a8q6-4?-f-;*VFjhN;Rbc=nsi&L~>AZJZ)5$#<`~^i^5lOOd&w^ zD{!aVOt!R)W3gNJq3Aqy)hLF4ZF>sRX`<#idt9BSmRiQ^0yKRJ0?zZ%lq zex~0$h?bIvsg(;hq7D5-c8Eo+(XVGQu?0xIXEW+v6dNGn$#iDtD$(%_@W z-ukvMghux z1Q=7ovE>!p{@t(XEj!^bljkh(rV)6d1N>WRrpF&&9g}GRpw7IS3SwtZ8Bm8+?Eji< zUp_^YgJ|RwD_$%B8nfxLTt^A!M8N^BPc}3XyeO3+mT*s#wU;~`7y{EW3lUP6>-fOy zj&wej=rj)wrk-r!hE^dh3}wOhe?^zg<&Q zy71ty^7LpU9MTi;)4MKiYNYalS({|A%G{2vROM?b;tAgd`VSO;#UU4%cVoXO#0aZv z3Amn02(?=&--gnC4ixf=uDbs$rwDift7W{P_?|DBJ%6J6HxD0j+114o8Lj@6a59#& zw}{mju=z$4)1*%A5W?pogL3$2Qd3=UPUBxXJXR82gbYEv*cVkd+cbq9>V$U|1thm=Jv9L)#el*9>6})Ds%KLEV-nw-olUuB;+Kt+mo~aXx0OY(8mK_*~K!y== zm^SAuULOb{>)%=F&|TCvz0~GH=5aRrKgTY;dI8Ux_n&_+z~~GW^vpJe?~`9Hjh>j7 zX1;#xNA1y)A739qFh`@Oqk!EoV5^-AmiXk)uJ&Q}TgV%dp-|A|92kl&eh7Q$u1i-X zT|joR7RYoh-fNSC@(7;SYLh&BU_ITq`-hAXoMo+~jb~;&9Xu|4t_1H|hm1M_JJ4gH zuc41-G&u>*0gTuwpDf}ujV&252MCw|fbt(m9D+1^6~7{g$hZBWOyd*ucxOp7J<2!G z*&4qd9|2|?F$=hrfr3tqjtAe}jtY_W( zv;g^EkD9{a-J@X^q-28}fTI zJsGjx+s1*;fA)-^cj%0bw=}&&uOvC2nvemApDPp#SnI{|2wpWL3_E|9GM>C!M|k~o za|MvHrNS~B`9p+`9*C~_vzg1hOaAA=#$mkmW zXVS{1BDq9^l{VSAawnTNoh?$a+V6CdRt7f3ccClHv$G3yITb6qNbPMDu#-?CIBmB6 z*b!%7`%&o{$Mb&74Tl=}-y#ZtPcmq_q)hbW;2uI%+-jK3kX-jj*TQd4zJ9rIL7YOBw`sgC_JI*Su4$>IfpzUkPRVc>b$ZMU#dmd~}A!oq@(0 zUIf&@r&=v4<3`(Y?KXJHG)i>hZW&XKOhZ04av&LO#D4N{?^M{d2h5~))oFsW*Ueyn z1sV=*nmcy;UyBN0X#1p!QE$xCz9#3sur;lPg`+Ex2~+KEFa|?L)$odl1`wg_eyZdA zRVYaa^%bvleDgHWI1r@2MkNDmaY1MbO91h<@{qg3H|o0__dbOn4gHsgFc}%qSN{!Q zQ-?HL01h?yOdJM~iGc~-P#|rR^mi#AJW75QQvZZH-qz~rycG9#+FZoLE=%|=KMcn&(U1#H2L=*uG&Osk zARS`ekoJv4;7n)3>tj{7v1qxG2HZSq+iN}V5bEUsRnuIBYhVB5 zYYhG871rF*1bP$tF&q{si=nLd{yDoXTS&Y_fvHIM=hWejQA z17zeF#eCAEVIKo8GB68$_o+{pe&T{$_MY%Ch2R3O#TP)@gxX*dRn5=RqVJ6P%H>(0 zk_$XiQwq{BEro;GIi6*M9rwTF{S@DxL$pQJu|$+80NUe51N<@)mo2~CCLItb9bnqV zW2L%Cr-(Myr3M6v=)ok`BBF-~I~!_vki~U*Zt7AR!73Z$F^Ss2(K-)tyT1Z>FY}D= zz6^dXtKo*Ggz3}Vh)xbK-wNs^*N6BwKEf3Up%=6;8g2g~SYr`iLJ@P`4~JJ3fGZR5 zV<@Cp)ziXToOpIn!BRiPR4kB?Ok-&HU|HM2(!U|KIAXL6oDcB4vebjiQ`=t$tP9m% zso1w&-&%p<|8+2b@mihjSo{0zbE)&k5adR9C+dIGIT+=%c{@JKIPv9w(lDi$0>k z=Cdf64(_Mrrno+7i$?3F0TsMMF%_HVa7(Xx^^<;cvN%Aud!?ohFgWqFO4WjCCQe@t zBn7v@6B+TueRcmEX>Sg@T8I*sc^jl;=;3f+d(C4K>OS5~`cH^n$BXo+LxeJYoVp>A*v`8mE|8B$yp9 zYEO?L2S6lu5iHegrH~Pg^S)8n!ppagWHk3Hy8Xrhq1L+CZ(pET>)w)_XcE|M*Jq{WXeXA7rcLIQCjMhjRW+#SSuCfHJa>EW&bN87j#7w>3N z85zLVz4xX{Tv)c0g_>3Zn;E;^jmP?zUdG#(WS{MOM^0gl4=9kNnKAtJljgdrzi)Od zb@kUWXn~_mFu5|;(^qGQukw(pGX!Fli*YRW{H9_7p0(*#d5ewv7lNibV>lfXW8`$L&Pl@URo(lOubN2;CtGeffNNnXU}1>(q2MQx z#P(nKhn?wjEGi=%4<5tG=a#gi-{W|M;S!QX)ZhWBseuZHy81o-otiL#{b)jBW$mGc zxAnorK+xl#)QBDmwojP|CvQ_-nF^OUi8f3>LezpjqrpF0#S=+%cqa&pRV10_+{L$< z#5prMS)(+!(1PG|!DD!ZuP`J;r*%88%o_6}rFZTra=m7d?#S2%6-QACrC#mAUgYv7 z>BIIfH(Y=#r9crE)>?}G==8|z4WOo9X{u*E>vtpl={AUYSVXWE8{|tM z;*?b1mAL&DA)iU?yk1Vj(AZyob)hS;t^mpQOx_8Qd~3tXi*bTIN_WHKfFA^VT;w%+ zO4bZGq<;YUwVJm^>vFT)d3)M1Up4z>7HpNw+hOc^Nv?`m3=wK3TWu8|L4e&*4Nycw zFTBk4qPIt&wp&Zrjp9gOkNEs7^RAXd_}`y(!MFH`DSB|B{cP%!UA*YgMwpYFFNY>0 zP;Ql)f^ma<`uJ2aNH&!&IyV#&!bXoUBZeqDVo1*fY0TGEqAn`TjqCdt2e=Q4 zX6X#F{84skmYR0TJW>C?YOp6Mt>1W`Bf)w5e^gh5|3}k~%ImmdAISees@5CTPE%TX z!`*OCDuTlyWbm>dlst=2UEJ_=6z=2gSUy?!`pCp{DGn)AMmU}Qq9#BCt~(*$4PTub zKoa*7Iig@PCMc1Jvp!=h*))80!G9NUQIMD6%UhR`AHp_tIn8BD=MsUQcJsENLOIHa zUx_`LAxj}o-8%r}4-&5(j?tQ))mR>rXsAn<51?3IApOTT9eQYw94htp+C+ORNy%&n zox7i|Q8~qfR>9vgT8p*kZjE!igC=2|I6nZcORl%iiW^qbKT8IGXBPSBysiDK+U~O4 z9cey`whHX;tu%w4cl}9-kAh?j|>r6<#t#0P|=phVqnAoHTBGVvsDaLnT@+vf2$wrZ3f7hL?fGT#o$%y;l*&1Y_B^ivZ1h!s&}44o}ya;ZKayQ~K*ZOFHf8A&o^X z`i1>Wt3xEeHc%$^1wPhir|%%9?+#ndRCU*|>&s8J%um(Vt(BF-#W7}+t<+E_b_`fn zp!2kkelngyF=o1EbZ=igltc(wyWDxKVjcSap{cHZvetqT$?Lelua`Xx>n4F`0zOzf zlvcZ8>BP>CqGGJZm$pQSa;^7GqLQQEX0rQz_bEFh)^@%bjwLR59>=NWh%4}3J~h$! zGq4HevJ%#@dNFK==M^wR0OsxY@7Z^bF$nRvm`pIyAd0BE~NS)wMHx;G|)hCSm zU~$59j;r!4tr>C14IfeU*3gf=GHIVv)Zemf#hd-FOa1rtVw)b$$IwRzkqkgic>uwH z)dMN)-zwY(r{j6YD~N-jc6#w(PcsWpP(PKthwvty-T0$oCs&)pp zED7hXPi@qWgM`(4chjsw>%`U^`rqmc1Ydh2=&Wf4*Ozn+8jRRQ*0H58=qud=;5-~w zdTw_4D-OG3&^^7@UHu}aW?{jAd4+lGAjajkPxhyhhiY+_(&*3rPBjzE$NX(k>l9f& z1TI`eN4b|UkPRBi=lD@oKO@0W8m}MaUwB=HL#gXTSzWw&m9h#1_9GEE4gQ&NDR$_E zr6&(t`fZl@)!sEjqxtu_%rkL*D#>OfP~{B03*@ok6ysIqCM+mx{ISW=8h`23{=?n5 z`3pVKPbp(V7N<@+VWBXR7&Ggt`@}$|pT4y{L)MqsJU^jCXFQvI+pOY`9y&kWM20VS zzAF{%p9)Bb2!+iac5aroOw1CdGpG?PPQX32pF1Wxowl83z8}m(_T|-_$qgFV4F1h5 z=5c87GowrR44VXCXUNVe^Y1MI&xDZ8!AQCUlR(7_sx`$bEH+B?};e=GQcXzf!Raai&V!X1C1 z$fQvzkpCtiv~!x=tN*K!TkmmZz+%jh$P2MQJJEbD&X6AYBri+%(D$HMn=0bX4@L%> zL0#NBnSMfpvBIR~@1W2&)i5N#GoL4K|F)JONs{cj^cL+U;kvKKKROiZZ^wc%C7+L6 ze6nBIV$w-yh10fbSZ3qp1;y%-`WSz)Jo@*a40xkepftohB}0yNL0O^-);{=uIgBBs zOzVGv)c4))tYXc{y4lB8vo9N+;OkIi0eTUn_KW!Gux}7tvGc+_t{z#$qEGfaQ(o;+ zEMh)Ly=}Ml_KVi$J?6x3EYjwevK`Y2-eD@5=@ZKGhN%|(`5~N9K=iZoJ0m4hn9OLI zXmlLO$6t%h*Xce_)2|<6PNGvzGskkCoNSR@2Qkzx z|E1s*`Z*xY09e|6jk)HwZ%o4HzyAfwbzRpA{@M!WQ7)6PEdK?R@~ySGro+);cvQ{%loKWsm>Z_}Up#0fJ^a&pcKBnPpJ-JBXA890^pPXr8`sBMG-o}A ziwgM^nOb-bXx0iJ3t~hrFCXU~ws>rF>Kf10FcS*eN9}0Y#l!0E{z11|UqBBgt&zV8 zYWG44vJST#f1Eu8t@$lBJd|g9HPvHYc)iGJ58%4$j=9BwPH9Xypq?xctB%2Pbl1i3 z)OtrFZ;RCUgu^eru47zQ`K+c2ae{2l$a`QFv2D5fYG2c%9**8XFVYiU&pO0{(b z8~$F-euQT!YeCNLmGU&j<`FdelRmQV!PwUPT{&+P<$#dQbeevb%VyqO*6(3&Wiobx z{i#EuKMII*)7-^8>-?@emra)8;b-!2_ua^2(e3Jso{#g3dol4mUyp)rS%=$7xEas@ z+AB|@-zck~f8|;06xc!=o6q5NIcdkfW|2vdNy=o!`DV+VQ17i_p_LOmDB; zqOCkOE&2OjNM~L4Hr`J3HCBQuoxu7;l+Ue=cn8;PJ6ijwTwOgCPuBOCSCt+N=(le5 zee{@K^8Rz8Oet*@Hl(^EQ}2pY3C`$2@CS_Ohr3~&cs3yFDM80`iyhc2#DOwjoV}++mL`SBD#&D zrYH-wW8T5Dk+%_?*YdL1K0|#0k^ujlVyUo%#;!EHG8cPllrnR7pE^f15y$$0+G@YP z*OKaVv`|&+Gx49P?5YD4XEykn8Dfh~ZxPC!%+I89S)RCmDg_?-oqM=h!MW-R`f#kg zF+VwByWLNZXDoH_+bfTyiF$4ZWDlk-{%Ws~bmLCr?7;7*E7e}iO=N&7Fr;XJcYjyD}uwoh^08g&QR8-H)%U6lZ18w5g=dHX-@#h$qJqvql_cV*m&_x4*iw$=> zTZcUNOV6+eEL?Q$b>=SyaD?ghsZ?mg^np{$o`>|%KLi5KNwW3& zaSD-)IcKGe*Oz+>!QQQ^D3L1-y?s+@DzaiB#*xY{UZDw5F8X3YK{>eEA7lZd5 z*=1-Vz$XwS-u&~P`it|zNv-{{Aq2Yqa>y~xfb2U%yJIpY4wO(<$hIAM!?@P`dTwE2=(^7{Z~$ zeR9ZL*pAWH#dD&HeN%GfJ|)rd|6sJhF3foUaR!O!kPqMme3lG zSKAaDYQG+R39+qNx>n0YK!g&<3Fl%v@{V|5Gu(}8mBWGTf(T8h406HMDyE?qPyCAvj=W7uirW^!q%Yh;%{o;V7(xU9+; zUeEU5fE;vt$0YpYFBYQOf@Ly}tYMo|Aq31G#Y>k9)x8Mjpi(~n7w6gYY9uUWnQ{sV zMiPNxUU?+-+()A^ zun548ih{*@$LQKDFKt0*@nPlKE2z`w^^EIVPk(fD?vfKpPG|8C0&8}pbNJH2?5>3T zILqB?GUEM1MlEB<4EG#a*oNT25-5=OiP>=CMxcJ!3FTr4k0@U`hH^BeaDR282%)y* zzFT$W^-pS{{iRww$BpK>a_T!}Qa$jL5ItB~se0!RrI_#IgnwAEUKuY@=1fsZ2b1pb zW^$q5T!87tNNI>{0?nKLKkM^bHDABb)2?B^d%fEe_#qukCicpt+VX5&vI44#2+e#_ zl83h){6|Vr=-G{{ljVx~_;E#AZTI6p?din28#`!B6rnT0ZH)6KNruP^Xy*CG-#}+X z!mE35@;{8WFw1(yxldTB#q<6Cm3axcaB+&Utw>JVvIRx^w?Z%rh34ws4aCffBH)M@ z4;ZFT_awdVb&Kb{TP`0hsO2(Ms^*|;zT562Bo(1)8Hka6({i~3D}EdHm0tU}-og0L zvJ`t3p-sDn5f5rr*76i<+MrzE6GaM@9~dsc*mg2KDJU$;zhU*wxUmT7qT`}m+apVF z^~F=;UVxSVsmUo)LBmCuIIfzC!uGPKDTRw^lk)MtwZ#)XCId2fu1Q$&^UT^73sG(l zV*-5g!h<{0w;h+!2$%6n4F6M`n-=ezZCO_qqQ4f;EpC~`!{S^*stiBYb~u7! zlV^=%Tyw|~n=SE<)=(<%Zk$$nHM6grzHv zY_sj_`{C83;dX~W@i(Nsc$k$3RcH#HSXJ(mgYa-)BLIvV@8Y?%gKeZYH_MLMZB1X0 zC|i;9ezX*nv*NwjPPGV~ysqfHoJ5tYXqUr5|7>aYMFB;ob>Md@-@XVH3N^ldhcgO# zQ9jTef#hoSvr7|+#bZUIXWp}jjf?nii}AQ4MY;Gsbz%IW+>yuV7fmS z!njlY3S^$1@zw2#B1RfFZg%h@YUIr{PhV^d2W1sK^!?<)A8TFfZ_Zeb702#;Gk1Eg zQ}pom{(C>Q?pGc;imgx40x|=RHT5*z6X!7fG3R)fcP>0W^R$uOQQu$1#(o1jr=DKc z;r#D!lu^q7`M2r~ly^kKtB;IjBH3F$!x_wc)CV>Vt`f8mXl zT*D_@I6KE|i$#leq40vjn!MZCRIjS+ittb6LFvoJnh8gRA^uej|F5~PY>KOS-dyZnEy9VXNsLFqpV_gW@}|$6L6$sDnoezohpqIi7$<*wBu)SlGbT37SZy(Jl?;$nb9WfjVev_4-~+BE3HrDQG6AD62&QYINj#Yc|Efuf-x%=L{v|~C zPDVd*D*ABjAN+5kyHy}>fjMt3h?2mmte=X$xFQS9wZjCC=4WPBN1l6cZMss~-$o36 z+pl<|7`ilwe*_vkF68!h3E~2=m|NbuT|OcodPW=G3n2vWkrE*(Hnc(*3*H9wurmH|(6>`y z5U5qzfc1rC()#Y4wzrY(!d98WN$tTSurkrmCv-^Q2SrgjJ&}qzIrA0lzL$5el3~pI z4zBDU^t7o11XztXB_3qUt$E$zt$1e!ab(AyBld zx#7BLs?4PN{7dv~wW6HeYnBb z`!{T0r|oM#Io`;{-{;o97}tgbKaPUKFVUSB%ytOBk0myiN)4@s2<2Z@obx_#<(J+w7yhBKQJu74tjlbx8K5dnKV^2EjT8 z$JE_356`O$i(E!|9kslqwDrfPFrw7ScuDsrq(usPI~mcu-@pRvF!icxt6F<8zhn(G3-{yt5 zGzSX9ge9O1QqG-FHq&LXx4M#TKp#~~2%IuIq<>82uLGRba>{M|G5L)o-aD?Zee;AJ ztj0(QN9F=kKEc5_ZN{QYQuyXWkdYbxkwgJ_n&EIPfFX}5Z_0I{fQGKim3pP0?ivEZ z$?J942F)VX)&?G#^$x`f7fwNg?){o!5DJ!?>*<1&t(P>VN83lt_Tq-P=|G6+rC;gi zDt~8GZ=lAwDiH!WbCs|?h3!4+%52*HdOUT6FOFbEm4ITXQE?1EZ{dz~NC35d;hbYN z)Am`!G`|zG!@Z7f0^G`s6R_^w$91zBUdH43I{jsYVB?#R7A1$o5a=8C4y?A9yOx&= zVQH(+G`)~Zwsr3#K3CVS1YuaDf9oBFqANur*A_?tQ}YN~eUs!$ZG z=Tdrpi^N*?H91LZZDvT#49aN=$};BUE{7>^zHkwQ(0&bo8Vfo5M&C+%ifXt7ZZ1j% zKY;AqFHrU5mPEv?G8-6vC{5MvU7MZnuO>@L>lS#Yw4G8*yY&$aA%c_ERW=PuH%^kM z&9a6@bjg!&bRBcp&WjHX{^>@rUPTMZ zm#|YD9fR8Mg`QigcBQqPKrg8dS8BQ%-cYL>f1TAcXAE%Q&L=iAjSug8Kf7d{w6KJ$ zoT;zq{IWVwMhI1mk4?t*7<{)m{0?@-@};0*szu5)=mODz9XhAWd<8Oj(_tsKZcvkr8K1P1Cn~6o|i#4 zKCSl+fu=-fFkiL_b!XWtswtLHwxteh`}uIRz31=w9%EJt+S=ZDE~wOqrWpp$i(hg3 z#O?LBeF)ea`%nIu`hLk)@JYb@X%_jm=5H+pZ>GF%K*#mru#=x#O2M;bt02s<6IYm9 zFUI!U9I@!+w+Bp3ZjwQuWWM{tLB8wr6lr(R?@Kec(O|;uye2%Xi0QzKxxnps8an~% zmXuQmf#1M*gO~sT3HRGo zRtNl)4~*zYgIz~+A@AzTbB!hFl0q_?AB>oxu1F7ED^4q5PW_NwrQpXQmoHaGht-ES zYg?dXmSaU9h5kMEt0{OUkm{5H9IxnmC%~gDRUfHq+@vwQX7u7iA2I>#q8$y6gk=X- zC@V}m@G=CIjgXKwjDsfLDBX|xI>7TZ1>sObG=<8}%as{FtJk^-g}scF?DF9JY-=#} zzc}F%^0>Kx;SziblB8L8?)i5y?Qv1DrLiPacVQCrNRzZnAuR^{h|;~lNgvC4|A!vHId$_>Hne6&HhD2Mj*z$fB4Eo z)mdcNgJ-2}`8iQUoL`<3Q-F7lfX>23r8@fC$5Kl^dcnJ{=edxWt*b%RG6jIn_z&ri z5doK+-d#`hOR(4H_UHZp%9FDSpMps$kSH-q+HtDtqYG3G0WF~8GEVRXn%u3ua7#fA zW8p>iGgbhoYFwf?GlAauV<`58|7}HL#7cK?zx+j_9Y4G`{cmOQB|GOZ%38Q~6HVn6 zyRb+_VYN^2dEmDLKYbt#$;#l#fA)bk(mR+y-;9JfOCZvI1swBJqy8*T9z~@g zM&NS8cf~Rk!07+vFNBFPG9#yD%UNk_ol|fW&@gN_G-Gh&GVs$NJ4H7sO!oKtAb0b= zGp63k^xIxPNul_hPrQtXv>sg2$6~DmZ&V{Vd_xX6j6Kgt{5*&GgWQ`%wd4JQR!$P~ zP2tg<*V6jF^mlfc-fpNdg}x~SCAsGlX!3g-LKb3xHB~&|_%nSUMV}%g9Sto$`pmkl zx}i>DIR)N(dHf;=yv5l-{1MRG1TrfRgC{vj{O*U=-PV}Z;{;?5kMp4|oe^m#9U3y#FTNe#jy`>s#qEuw?f1f>s!Cuj8&vN&38= zQ*Z*}g+_U^)_Xj5)G@6=mJp>8P17Yzx?>>x?y@Cs@s01xsJ1=CR)6H`*E;!Z{+oK zn`~-YUY&p5mSi_i&bvC~Ld46g1-N7@PV#EF%}gptH7oPfR|KwDxwbN5Nx%h7dAI?l ztFa&6C=U9$sBvJUzIJny=Ew9=CnuuW*HuBu6phMvG$|2AjXcpS$h# zelvqQ=r<<9aJD%bixdH+aYtGK8qm_%P+T#QPiw>B6OJ=Z%;3@=Xfp!#xVtsuJLAKG z0_Ud|x9_^MKm>#4D)mu+K85n#zroyMw)yYNVyCa|-20m5kEV}%KIl*7!@alo)Boh|o;a7Wx0|4$gOF#`UwtHB279dn(W69jOI;iu z9%-3U5<4o$KeVeyTs%HcCGj}7oO7fEsW=o;6a-MRcAcT>%8(oU4w~@=v>0tR>f8dS zk;b;=nC=E6Wd$FJQJY+2^_Uk;Cy95C4>u))hRT+xF}Z>hk~D3zAXE-7dn-_3<7;AE zsRrSdkzUknI*wmil;j;q-O)tLfcDTTYbwu?NV!Zd$&7(h*mID)UinO2$lcQLdiFtk7KAjurbnexCN8v`;s3pYi|PRbRgI@QX~)gZzHH zUttJR0ooDv&=^z*T_#8b{<*YsMRwG z;e%#~0*w9dtAD(Oj!s}?p~-Y=W7Np$qB3&5Njc-a{cCo}_s~Udf8LKa{8xCE)v-v| zT0SY`Ik-7CuV+n|K%Aq7n|qvMLgAfgu%uiv^^59k=qCZCnX|psfRLejQGPU<^mADA zKZupqV$TD!3iY!fPge^k+i36hxia;qw*_%l@w)oGp21LP-jSCt4&-~j-=FHP8|Tk& zlTBmTI|`Yrjge%^d69f2SLgxT4XAe4k97$#LOjvp-+G>t_<&ra7zd&?h7F*JIzz=E zm92Al{{7GW^Yv7$*7oDC$Y|uVFl97fv0tP@-dIaguEOMa=pQDo1?pdx&kZ!CNG-*# zdb;zULH=KRe+G)O#Y}q`LWXfGT<_HO=m-bx|J@}k^fG|v97&*=fZOT7s1_P;=G$X0 z8N2n{GG@3_K|w$y?AvJl6%us8Jd(IeK=Gd@r~XI7s= z%-asGjrwL{Gj6_d7@7@e<8q6n@&}d>ZC>^reU!yM#79264B{4*G)9)J0433;q^bef@?v3uPel) z=@YB^4^5D9-FYfi#~zgd$h5+N9y&eXZDvEC2ONBAkL)-7tEcGbAhlR)ntp$Uc7|)abf>yn zHPsxK`aUyrc06k803@mP>db~gS&~z8A!czE$%gmAZ}^!>+^#gr`S$)5Z=+i@qddJc zfsKN?@%@Ix5RG3m79?(#I;}y9^lKr+co`KkNHQVxHfsm~l^)?7qaJCpF8qWDg!ZqozI}sy_)MA4GNY;S9!63sJ(vBegV1XvYntvLH}(@IA2V z@DJm<|9d@;txrKMZJ+|6Vp*u{L?IPt(2*{+5ftmQv~kuyZFY{v+X(Tbz0NbGusMw9 zZc@JP5Wm;XutVO#ZR6G&=Uq(w8p|_kpT=pq(-%d+SF~dlZb=`~ebYU*a+o&s=jMe+T`FXn$wv zOaD4?hT3wcmx;_xk^EvSt{?J6js5S%XRX+|(X>JnRRsWA_Xw{}l#H@M-!guO#7zuA zj{9Fc`+IYwl9P+6A*|+)sQY5R*Rdw+kf{fFVZpx>x~be)g2tG)3;}2iPEpOmg8V0q zQTcw)Y6`2XWe*`dzEAe#LU}-p_lX3N{#@m?Ni@Id1 zm)MAYs!(~^1ZevH0}RQVJ5@;93<_#_x&9IKLnKYXCB)$h{$bXa^37KE-R8fTtGuxc z;UxX%94@kYCUe358RM=*YUke11h_B7LTpP8j*I3aNR6Lv`drw4`Aa#S(Vm{jUh!O* zqEc=kl|ru zkfZ~wan2GY-6m|}&lapRYc2R60!7+oE(j1s)dw6A&(vcYLcs#Y566wAA{(r1d&)6lP<=VKU!EAD$}?#3SD_svIVf4hB3TjZqB*%>T~+fMm_4oUbzyT z)>{$<*Mx7Nt%-r{E)}bY@A;EJA1C$esK*Yn5<&+!?XN8$^sh@`7=vNCyPfmXq8K%F zVpFF;jmq)k=~5WcO($H~7yfDBX!%E^eOn{n?TWefmuNS<1lti;f(;q|Jo8Ed&xj13 zMUN$(wwwFh*7SUJMJ+ZD=Be$-5Bws*`@TsOqSPvGY}Piij3}nUk@7E( zdO9WjBjF>mzx>p@gPL)yzZ)unS|{-~tF8-yH4&au%LWQ%fXcmb!Jqv_PaN}rxyf`hN~sA^2JR!1ZmII78nEwP%CB$M0( zt;nRiq8oSLPDYh&*K=qUje3w`0qHHiD$$Zhy(g7ll4URr_H7=F-^G8^gkIx)&|*|G z-p&#%%g+|!g7^{)_CrSv^bGJ{Ua60fRJ&{TY;O1hh@@e*W8g-a^t1wa-h=b1|BJ4O!0^=dS|3^hwBw*~bF#lETsZ_F)1`%gi5rje8PH+l~mhw1Y4H&h?6UK~9l&8S6_wt-M~EW-$INn_ls zd=;sw5K{G2G&-y6L0Z-xz3^HTzc5WrYkQuvXy;64IU7P4N-ADqA-8{*b7!}6r-Wp- zD)YJ&?iAG*fflOLjSWTl&jhsvF(S);U+*t*0{dl@q(l^>yt$18@;~=z4n`78EVS6) z+->dmBnQ0O7;L-OpP!fn-nL?&*W8w_LfU{Vh;)9n@$i)te%!ta<$zbDZ-+N=_-)&b zYV(zo8cL9EVx4^TF2w^!`q?}p1m8UubUi8gKisrsPwk6(jCmburW=LANtP^HQm@9} zEx|lmBF3ys1~=3g$>|7j=4R(Uv`woeFU`5oWR4MFcIOM;Q@;kWje^ z!-h%In{fvwQuhQMDFwe)nEa69Z~!wP%0Lo6X^n+-l=8w)pJ_+OlY9AN>(+UR8@V)( zwCEhT(jsMq6g*pN91eCyAHYWy_dD0)I=!k)ETiL5m@$pMv#y6A2{eqxB5^bmx`Z&z zLQx{LCuq}<~K@p?BNuZ1XNCP`n5L9i(<_t!v>Az5Bot0@?iV+KRT>jozg|qre4_9 z70sA*=i|XlS5t&hZ&MhYBpYa)u71i(T&bBbHp|ETMcV?4&F!*nx0|BP!RgE%nzEI@#TwK2c&<9OS zp7aUepLT+h`yryr7_8WSwOJc@Rbg~|T^8u?JOBX!&r^vw5M_>oszPllal+Y15DtcM zE<3H>ESU(CH`dNpx%k zC&#GYO*_7L2)!Sz8I^CKA#5Rd1)wHeWGwh^rM)rL2%bKeQEfE0bAGBR`FeyvZO}mv zi0m1RCTC37Aa_CsOcs8e#J!YAN+ZFEsK-ep6H#EoC;Htc8wM=lGi>#4c)4TNt8unj z$kkiL`Cwhd!^T?AZ{?0(@rQk{MjMsi(Gq`um6kFp2@lDV6nLFT#6RO+qgg0_^arO0 zHc=}9er{%~s6!SDU1@h4W6zdq$^Lt4{JS+wx@O?n zB51p(45~E;0``-J_}a6yg}5-pbPk^E-o+koU^OWoLlY16x5jbd_AbfY4kH9K{Wz4k|&3!E^sqz zuv>1g zQ*;H^mqoM*dx3Wrxi<|$z6yO{L@Fv@9ZrZ0ooA+y*;v#sAxO-VXe0uL3ZiL?dYn zvXU@sw=7jAJh!{}B-n(a&arQhp@lh$cKJ~Mxi?15=oiHN9m!dn=f|z%?;W6b=t@`< z#pUC}lOGflYQ}6%+Yys~jOp5BF{e5HnIqbo5XSPeOlGt#I#??bq3|)mRiR$~BiXyE zB+$*R%{7CV&nT>l6q*u@C4YzYTZ083;5u;46nOSzW#B5C@dh!`^x*NXqVo$-AikWO zNwhY_CM+AL5Ur4zrsd95YISAm4+@Q!7xn#o!1B^@MHBz~@@09oh`2`1B(h7(Ax#!5 zr9*x<9qI@aaWdVLp^t^gqI!3Z*U|kXx+rGC`(JMBX0Qb+kjG7CcJ}mp*T()6OvRrm zpIHv-gAkIM#|&4JnQEn5-r!#@asaP~A^O%M+JJTxQ7`Q#`a9n-+K$gVd(mUNrC?m_so;AW@ZXv9BbmL(v`cXdjwM|~{V6w2aCzJFi8+~> z0CCDxRY=p0ALXzKhAg*}<#@{n9`S?B1$Rz#2SLCvw2+`cVU^%pe2P}j((gOCz`H(! z%KjNR&Y+8^N2~+doRDGzvVAN?g^l^+Zb`6oyVutOtE!6}%(>O32zm160V>9n%c|z_ z$rlR(USFCadlYjSvWw8cxf&ob_Ic(YJEL<7^qPenmM{bZX_>s{`u^)ayABwXc%78G zeBOdvF(^~r3vPp$T@1n+@SV4!idgu5$sW-6Z%lFhrHs!waFdtSt4a!ys(A7C&ZMM#4f`L2Uqs=b9^t}6pC@p@Y0qu9_qmInl6!`I*pta27;tk6euM3c zU#b4zl*hToKTVAXNqBygSgWQwzOIVNjC5kWDrH-c+CO@;j)!|ohxj}4;7T^;JqVRv z%>0O4f|2Mnf@tAkASMBY8Wm$s7YRT}yxjhDJL)>Mi=U8hh-gbd`7ca5j!sVIz4l;T z82Q_bBig^)hp{AQ9aqH#PMevFOt-P7&?AIIcLun3eFZ&hO-cL}B2U@QpNnz5IQsm_ z_YjYDTu*yjEW9eyIE{(3G)(njyz>9cNVNblU4VV$S_VndW6ZJ$KFM9x2<#s;|B=5#pCy7stg39=MwmX{zF zrYMuod&Od)1;tnt<)~^p#ZaO)`}#sNl!9SHrlx+~Yy>^B17{&*?TXHo@b+_n`l3!W zYIzhVOvY@9p3q?u9k;QLK~jlgO~DmWLV$)s38Ea2|FcZ1LDVC5M6?=}M31L*vQ&5S zsw7z&ry1ry0A`q8M|F4?eN?h`QWf#<2}U~e7W;gUCp>OZ7ZFSiDuu;*iLXjKns^L& zX&Kys{%-=FnQ(qL_R~pEn10?**0|UkK0y6?LZKHO;j^i;n*PV7NUWf)65SqSU@GH9=YkbUR(SKfoW&8*GTaFHVc6rHf=? zQV5VG3&Iv0svJV#i%8m# z0(c2}^#;yh2;kCn8(BC+G9pCa8J6bPLjz2T^`t*GsffBj&6DzUkciZ0ypGYrc-Z$o zKNn{uqvQ_OL{o~^;?1E`fv*pLadp-20w%V^-diBAj;vGjhCp$({n&#Sb#Ir?H)0eB% zn}HQkx_RQCZlQGd!oK{EpP8{jgzM4lGsStn!ef5F!uCU@k{lTi5@39yQN+)d?N+18 z{65`MDTzbV4;WoM6v`8apSm9A`40>ae+ITKS)eaK`IviJnu}x0xkdF&gSC;1@;j5mdk?7h2IL+%4f=M5C zAGrbce-4r=8|S6G7d;HALsZXJmCJIm`J;O7$H_=HWI~+|9bZvf8I4ca9N$jEHy_R~ zn1462Mz{#cilAKbsy%m~Zyeb!l;d~@&JX8KQOyfOp3W93YO;^-3&prxsD*?U)1FQiPTsZezra5_<%c{_@@b1 ztU#?URN#5l!;EX+Xf&0{{8GS5S5wT!^LpgKlT4>2dNM4v{d(yjgC4Huw~2gxpc58d zAV?X3DsQ?nSE4*=>S&n{S(PH~-HCZcm1J9P#!ft$W242V7#Tu2zPqN#*~!r3erX9` zE~s8ZcAu@@>uoJFuY;pHFeZ&nd@bT!eA~+9d$MG}#JAmFtPQNFP;vE$4WRdf>^n;ad`2zbLQ3o_O__c?v}o zkaTXJ?8SRplS{M$6S~v9mu4@dlN*KOW3<^#qLL0lTH(86xH-Bqfm4m&z&!^qUOmDR zf<6FF{VOG@7mr>sCnx(eLn15V8$IezC(PMwb=gAffXoB1_dv)%DSqOyr)Lyzj)2?_ zX^fb>Zro1VBz*76Lgv$pTTzozD??Kbm1uP2wv=^7d-OUu{~J3lsO;n1CVBreG{sa&8fzX1 z1J2X8JpXTqA7wPE&widbOaVF4n&K5OgAhpZ3H7};5Waj`Mp1TG&MI9;vJ@sunPd6y zSMe0DE=9_ap<}pJBGIWW-Y&P3vdZ2dM{e>x703WxQR@lNul_ey%lF+D?}e8eV4Wu; zVi-ZAguP>c^TPA(Hw#?NkqPB*TJ*)S**FNHE62a~3ZYbedVL&OO8>3@HCbX?V7t7X zG^I8?%nlq;nH1~Uo^q=2JS1vXNDz zhd5L8?G{~H!7k-n7QUdi0(riZU$*ZR_RzvN22!zE3bGDhxbLKI-M6_9ix3*WH7yVZ zb_2pQt`!j7*TMsF^}i@31BD-IRUgwSxr5WJC& zou;Qgg-&ffY6gK5Ar(o=Lu)wah(ZW4yV97&1CVfdVhFskTUMbNMNAr=U=c0UC(5m# z7cnDk`*k_QF7TYnwG_1w7#LcWcO`exaaNfUsIgw8@}U6U)%O3Be+nlQSAUng3PHD@ Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/07-model-loading/resources/textures/container.jpg b/07-model-loading/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys 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[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/07-model-loading/resources/textures/popcorn.jpg b/07-model-loading/resources/textures/popcorn.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c90443f1dfe87a07a0d89159f06c070e0a0fdab8 GIT binary patch literal 12718 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 M&oJX$?N`73f7bo;lK=n! literal 0 HcmV?d00001 diff --git a/07-model-loading/scripts/reset_build.ps1 b/07-model-loading/scripts/reset_build.ps1 new file mode 100644 index 0000000..975852d --- /dev/null +++ b/07-model-loading/scripts/reset_build.ps1 @@ -0,0 +1,7 @@ +mv .\subprojects\packagecache . +rm -recurse -force .\subprojects\,.\builddir\ +mkdir subprojects +mv .\packagecache .\subprojects\ +mkdir builddir +cp wraps\*.wrap subprojects\ +meson setup --default-library=static --prefer-static builddir diff --git a/07-model-loading/scripts/reset_build.sh b/07-model-loading/scripts/reset_build.sh new file mode 100644 index 0000000..89931e7 --- /dev/null +++ b/07-model-loading/scripts/reset_build.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env bash + +mv -f ./subprojects/packagecache . +rm -rf subprojects builddir +mkdir subprojects +mv -f packagecache ./subprojects/ && true +mkdir builddir +cp wraps/*.wrap subprojects/ +# on OSX you can't do this with static +meson setup --default-library=static --prefer-static builddir diff --git a/07-model-loading/scripts/setup.ps1 b/07-model-loading/scripts/setup.ps1 new file mode 100644 index 0000000..050d716 --- /dev/null +++ b/07-model-loading/scripts/setup.ps1 @@ -0,0 +1,4 @@ +mkdir builddir +mkdir subprojects +cp wraps/*.wrap subprojects +meson setup -Ddefault_library=static builddir diff --git a/07-model-loading/scripts/setup.sh b/07-model-loading/scripts/setup.sh new file mode 100644 index 0000000..7881736 --- /dev/null +++ b/07-model-loading/scripts/setup.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash +set -ex + +mkdir subprojects +mkdir builddir +cp wraps/*.wrap subprojects/ +meson setup builddir diff --git a/07-model-loading/scripts/watch_build.sh b/07-model-loading/scripts/watch_build.sh new file mode 100644 index 0000000..44a5516 --- /dev/null +++ b/07-model-loading/scripts/watch_build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -e + +fswatch -o *.cpp | while read num +do echo ">>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/07-model-loading/scripts/windows_setup.ps1 b/07-model-loading/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/07-model-loading/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/07-model-loading/shaders/3.3.shader.fs b/07-model-loading/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/07-model-loading/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/07-model-loading/shaders/3.3.shader.vs b/07-model-loading/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/07-model-loading/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/07-model-loading/shaders/4.2.texture.fs b/07-model-loading/shaders/4.2.texture.fs new file mode 100644 index 0000000..80ee6a7 --- /dev/null +++ b/07-model-loading/shaders/4.2.texture.fs @@ -0,0 +1,11 @@ +#version 330 core + +out vec4 FragColor; +in vec2 TexCoord; + +uniform sampler2D texture1; + +void main() +{ + FragColor = texture(texture1, TexCoord); +} diff --git a/07-model-loading/shaders/4.2.texture.vs b/07-model-loading/shaders/4.2.texture.vs new file mode 100644 index 0000000..85c9de7 --- /dev/null +++ b/07-model-loading/shaders/4.2.texture.vs @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTexCoord; + +out vec2 TexCoord; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/07-model-loading/src/data.hpp b/07-model-loading/src/data.hpp new file mode 100644 index 0000000..c58ace5 --- /dev/null +++ b/07-model-loading/src/data.hpp @@ -0,0 +1,47 @@ +#pragma once +#include + +float vertices_3d[] = { + // vertex coords // texture coords + -0.1f, -0.1f, -0.1f, 0.0f, 0.0f, + 0.1f, -0.1f, -0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 0.0f, + + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 1.0f, + -0.1f, 0.1f, 0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + + -0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, -0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, -0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, -0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, -0.1f, -0.1f, 0.0f, 1.0f, + + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f, + 0.1f, 0.1f, -0.1f, 1.0f, 1.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + 0.1f, 0.1f, 0.1f, 1.0f, 0.0f, + -0.1f, 0.1f, 0.1f, 0.0f, 0.0f, + -0.1f, 0.1f, -0.1f, 0.0f, 1.0f +}; diff --git a/07-model-loading/src/dbc.cpp b/07-model-loading/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/07-model-loading/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/07-model-loading/src/dbc.hpp b/07-model-loading/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/07-model-loading/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/07-model-loading/src/main.cpp b/07-model-loading/src/main.cpp new file mode 100644 index 0000000..7694307 --- /dev/null +++ b/07-model-loading/src/main.cpp @@ -0,0 +1,307 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include "data.hpp" +#include "physics.hpp" +#include "model.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Camera { + glm::vec3 pos = glm::vec3(0.0f, 0.0f, 3.0f); + glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f); + glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f); + glm::vec3 direction = glm::vec3(0.0f, 0.0f, 0.0f); + + float pitch = 0.0f; + float yaw = -90.0f; + float speed = 0.05f; + float lastX = 400; + float lastY = 300; + float fov = 45.0f; + bool firstMouse = true; + + glm::mat4 lookAt() { + return glm::lookAt(pos, pos + front, up); + } + + void forward() { + pos += speed * front; + } + + void back() { + pos -= speed * front; + } + + void left() { + pos -= glm::normalize(glm::cross(front, up)) * speed; + } + + void right() { + pos += glm::normalize(glm::cross(front, up)) * speed; + } + + void update(float deltaTime) { + speed = 2.5f * deltaTime; + } + + void mouse_move(double xpos, double ypos) { + if(firstMouse) { + lastX = xpos; + lastY = ypos; + firstMouse = false; + } + + float xoffset = xpos - lastX; + float yoffset = lastY - ypos; + lastX = xpos; + lastY = ypos; + + const float sensitivity = 0.1f; + xoffset *= sensitivity; + yoffset *= sensitivity; + + yaw += xoffset; + pitch += yoffset; + + if(pitch > 89.0f) pitch = 89.0f; + if(pitch < -89.0f) pitch = -89.0f; + + direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); + direction.y = sin(glm::radians(pitch)); + direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); + + front = glm::normalize(direction); + } + + void mouse_scroll(double xoffset, double yoffset) { + fov -= (float)yoffset; + + if(fov < 1.0f) fov = 1.0f; + if(fov > 90.0f) fov = 90.0f; + } +}; + +struct Config { + Shader shader; + Model model; + unsigned int texture1 = 0; + Camera camera{}; + float deltaTime = 0.0f; + float lastFrame = 0.0f; + + void updateDelta() { + float currentFrame = glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; + } +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +void mouse_callback(GLFWwindow *window, double xpos, double ypos) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_move(xpos, ypos); +} + +void scroll_callback(GLFWwindow *window, double xoffset, double yoffset) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_scroll(xoffset, yoffset); +} + + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); + glfwSetCursorPosCallback(window, mouse_callback); + glfwSetScrollCallback(window, scroll_callback); + + return window; +} + + +void processInput(GLFWwindow *window, BoxTest &box, Camera& camera) { + + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + for(size_t i = 0; i < BODY_COUNT; i++) { + box.bodies[i]->ApplyForceToCenter(force, true); + box.bodies[i]->ApplyTorque(0.1f, true); + } + } + + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { + camera.forward(); + } + + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { + camera.back(); + } + + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { + camera.left(); + } + + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { + camera.right(); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + glEnable(GL_DEPTH_TEST); + + Config config{ + .shader={"shaders/4.2.texture.vs", "shaders/4.2.texture.fs"}, + .model={"assets/popcorn_model_a.glb"} + }; + + config.texture1 = load_texture("resources/textures/popcorn.jpg"); + + config.shader.use(); + config.shader.setInt("texture1", 0); + + return config; +} + +void render(GLFWwindow* window, Config& config, BoxTest& box, b2World& world) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, config.texture1); + + config.shader.use(); + + Box2d_step_world(world); + + // time is used for fake 3d rotation + float time = glfwGetTime(); + + config.camera.update(config.deltaTime); + glm::mat4 view = config.camera.lookAt(); + + config.shader.setMat4("view", view); + + glm::mat4 projection = glm::mat4(1.0f); + // fov, aspect, near plane, far plane + projection = glm::perspective(glm::radians(config.camera.fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); + config.shader.setMat4("projection", projection); + + // render the loaded model + glm::mat4 model = glm::mat4(1.0f); + + // get position from box + b2Vec2 position = box.bodies[0]->GetPosition(); + float angle = box.bodies[0]->GetAngle(); + + model = glm::translate(model, glm::vec3(position.x, position.y, 0.0f)); + + model = glm::rotate(model, angle / 5.0f, glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(time * 10.0f), glm::vec3(0.0f, 1.0f, 1.0f)); + model = glm::scale(model, glm::vec3(0.3f, 0.3f, 0.3f)); // it's a bit too big for our scene, so scale it down + config.shader.setMat4("model", model); + config.model.Draw(config.shader); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + auto config = setup(); + + glfwSetWindowUserPointer(window, &config.camera); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box, config.camera); + render(window, config, box, world); + config.updateDelta(); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/07-model-loading/src/mesh.cpp b/07-model-loading/src/mesh.cpp new file mode 100644 index 0000000..3431e3c --- /dev/null +++ b/07-model-loading/src/mesh.cpp @@ -0,0 +1,56 @@ +#include "mesh.hpp" + +void Mesh::Draw(Shader &shader) { + unsigned int diffuseNr = 1; + unsigned int specularNr = 1; + unsigned int normalNr = 1; + unsigned int heightNr = 1; + + for(unsigned int i = 0; i < textures.size(); i++) { + glActiveTexture(GL_TEXTURE0 + i); + std::string number; + std::string name = textures[i].type; + if(name == "texture_diffuse") { + number = std::to_string(diffuseNr++); + } + else if(name == "texture_specular") { + number = std::to_string(specularNr++); + } else if(name == "texture_normal") { + number = std::to_string(normalNr++); + } else if(name == "texture_height") { + number = std::to_string(heightNr++); + } + + glUniform1i(glGetUniformLocation(shader.ID, (name + number).c_str()), i); + glBindTexture(GL_TEXTURE_2D, textures[i].id); + } + + glBindVertexArray(VAO); + glDrawElements(GL_TRIANGLES, static_cast(indices.size()), GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + + glActiveTexture(GL_TEXTURE0); +} + + +void Mesh::setupMesh() { + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Position)); + + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal)); + + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords)); +} diff --git a/07-model-loading/src/mesh.hpp b/07-model-loading/src/mesh.hpp new file mode 100644 index 0000000..50b515d --- /dev/null +++ b/07-model-loading/src/mesh.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +#include "shader.hpp" + +#include +#include + +struct Vertex { + glm::vec3 Position; + glm::vec3 Normal; + glm::vec2 TexCoords; +}; + +struct Texture { + unsigned int id; + std::string type; + std::string path; +}; + +struct Mesh { + std::vector vertices; + std::vector indices; + std::vector textures; + unsigned int VAO; + unsigned int VBO; + unsigned int EBO; + + Mesh(std::vector vertices, std::vector indices, std::vector textures) : + vertices(vertices), + indices(indices), + textures(textures) + { + setupMesh(); + } + + void Draw(Shader &shader); + void setupMesh(); +}; diff --git a/07-model-loading/src/model.cpp b/07-model-loading/src/model.cpp new file mode 100644 index 0000000..f9942d6 --- /dev/null +++ b/07-model-loading/src/model.cpp @@ -0,0 +1,169 @@ +#include "model.hpp" +#include "dbc.hpp" + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma) +{ + std::string filename = path + "/" + filename; + + unsigned int textureID; + glGenTextures(1, &textureID); + + int width = 0; + int height = 0; + int nrComponents = 0; + + unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0); + dbc::check(data != nullptr, $F("Failed to load texture {}", filename)); + + GLenum format = GL_RGB; + + if (nrComponents == 1) { + format = GL_RED; + } else if (nrComponents == 3) { + format = GL_RGB; + } else if (nrComponents == 4) { + format = GL_RGBA; + } + + glBindTexture(GL_TEXTURE_2D, textureID); + glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + stbi_image_free(data); + + return textureID; +} + +void Model::Draw(Shader &shader) { + for(unsigned int i = 0; i < meshes.size(); i++) { + meshes[i].Draw(shader); + } +} + +void Model::loadModel(std::string path) { + Assimp::Importer importer; + const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); + + dbc::check(scene != nullptr, "Assimp ReadFile return null"); + dbc::check(!(scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE), "Assimp says incomplete."); + dbc::check(scene->mRootNode != nullptr, "Assimp loaded scene doesn't have a root node"); + + directory = path.substr(0, path.find_last_of('/')); + + processNode(scene->mRootNode, scene); +} + +void Model::processNode(aiNode *node, const aiScene *scene) { + for(unsigned int i = 0; i < node->mNumMeshes; i++) { + aiMesh* mesh = scene->mMeshes[node->mMeshes[i]]; + meshes.push_back(processMesh(mesh, scene)); + } + + for(unsigned int i = 0; i < node->mNumChildren; i++) { + processNode(node->mChildren[i], scene); + } +} + +Mesh Model::processMesh(aiMesh *mesh, const aiScene *scene) { + std::vector vertices; + std::vector indices; + std::vector textures; + + for(unsigned int i = 0; i < mesh->mNumVertices; i++) { + Vertex vertex; + vertex.Position = glm::vec3( + mesh->mVertices[i].x, + mesh->mVertices[i].y, + mesh->mVertices[i].z); + + if(mesh->HasNormals()) { + vertex.Normal = glm::vec3( + mesh->mNormals[i].x, + mesh->mNormals[i].y, + mesh->mNormals[i].z); + } + + if(mesh->mTextureCoords[0]) { + vertex.TexCoords = glm::vec2( + mesh->mTextureCoords[0][i].x, + mesh->mTextureCoords[0][i].y + ); + } else { + vertex.TexCoords = glm::vec2(0.0f, 0.0f); + } + + vertices.push_back(vertex); + } + + for(unsigned int i = 0; i < mesh->mNumFaces; i++) { + aiFace face = mesh->mFaces[i]; + + for(unsigned int j = 0; j < face.mNumIndices; j++) { + indices.push_back(face.mIndices[j]); + } + } + + aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex]; + + // we assume a convention for sampler names in the shaders. Each diffuse texture should be named + // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. + // Same applies to other texture as the following list summarizes: + // diffuse: texture_diffuseN + // specular: texture_specularN + // normal: texture_normalN + + // 1. diffuse maps + std::vector diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse"); + textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); + + // 2. specular maps + std::vector specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular"); + textures.insert(textures.end(), specularMaps.begin(), specularMaps.end()); + + // 3. normal maps + std::vector normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal"); + textures.insert(textures.end(), normalMaps.begin(), normalMaps.end()); + + // 4. height maps + std::vector heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height"); + textures.insert(textures.end(), heightMaps.begin(), heightMaps.end()); + + return Mesh(vertices, indices, textures); +} + +std::vector Model::loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName) +{ + std::vector textures; + for(unsigned int i = 0; i < mat->GetTextureCount(type); i++) { + aiString str; + mat->GetTexture(type, i, &str); + std::string tx_str{str.C_Str()}; + + bool skip = false; + for(unsigned int j = 0; j < textures_loaded.size(); j++) { + if(textures_loaded[j].path == tx_str) { + textures.push_back(textures_loaded[j]); + skip = true; + break; + } + } + + if(!skip) { + Texture texture{ + .id = TextureFromFile(tx_str, directory), + .type = typeName, + .path = tx_str, + }; + + textures.push_back(texture); + textures_loaded.push_back(texture); + } + } + + return textures; +} diff --git a/07-model-loading/src/model.hpp b/07-model-loading/src/model.hpp new file mode 100644 index 0000000..8d23203 --- /dev/null +++ b/07-model-loading/src/model.hpp @@ -0,0 +1,40 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma = false); + +struct Model { + std::vector textures_loaded; + std::vector meshes; + std::string directory; + bool gammaCorrection; + + Model(const char *path) { + loadModel(path); + } + + void Draw(Shader &shader); + + void loadModel(std::string path); + void processNode(aiNode *node, const aiScene *scene); + Mesh processMesh(aiMesh *mesh, const aiScene *scene); + + std::vector loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName); +}; diff --git a/07-model-loading/src/physics.cpp b/07-model-loading/src/physics.cpp new file mode 100644 index 0000000..daa8f87 --- /dev/null +++ b/07-model-loading/src/physics.cpp @@ -0,0 +1,49 @@ +#include "physics.hpp" + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + for(size_t i = 0; i < BODY_COUNT; i++) { + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.5f); + box.bodies[i] = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.bodies[i]->CreateFixture(&fixtureDef); + } + + return box; +} + +void Box2d_step_world(b2World& world) { + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); +} diff --git a/07-model-loading/src/physics.hpp b/07-model-loading/src/physics.hpp new file mode 100644 index 0000000..dc98a31 --- /dev/null +++ b/07-model-loading/src/physics.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +#define BODY_COUNT 1 + +struct BoxTest { + b2Body *walls[4]; + b2Body *bodies[BODY_COUNT]; +}; + +struct BoxTest Box2d_setup(b2World &world); +void Box2d_step_world(b2World& world); diff --git a/07-model-loading/src/shader.cpp b/07-model-loading/src/shader.cpp new file mode 100644 index 0000000..ecbb1c3 --- /dev/null +++ b/07-model-loading/src/shader.cpp @@ -0,0 +1,109 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" +#include +#include +#include + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} + +void Shader::setMat4(const std::string &name, const glm::mat4& mat) const { + unsigned int loc = glGetUniformLocation(ID, name.c_str()); + glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(mat)); +} diff --git a/07-model-loading/src/shader.hpp b/07-model-loading/src/shader.hpp new file mode 100644 index 0000000..d1aa2dc --- /dev/null +++ b/07-model-loading/src/shader.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void setMat4(const std::string &name, const glm::mat4& what) const; + void cleanup(); +}; diff --git a/07-model-loading/src/stb_image.cpp b/07-model-loading/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/07-model-loading/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/07-model-loading/src/stb_image.h b/07-model-loading/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/07-model-loading/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/07-model-loading/tests/bad_shader.vs b/07-model-loading/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/07-model-loading/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/07-model-loading/tests/main.cpp b/07-model-loading/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/07-model-loading/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/07-model-loading/tests/meson.build b/07-model-loading/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/07-model-loading/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/07-model-loading/tests/shader_tests.cpp b/07-model-loading/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/07-model-loading/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/07-model-loading/wraps/assimp.wrap b/07-model-loading/wraps/assimp.wrap new file mode 100644 index 0000000..4bb6029 --- /dev/null +++ b/07-model-loading/wraps/assimp.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=assimp-5.4.3 +url=https://github.com/assimp/assimp.git +revision=v5.4.3 +depth=1 +method=cmake + +[provide] +assimp = assimp_dep diff --git a/07-model-loading/wraps/box2d.wrap b/07-model-loading/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/07-model-loading/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/07-model-loading/wraps/fmt.wrap b/07-model-loading/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/07-model-loading/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/07-model-loading/wraps/fuc2.wrap b/07-model-loading/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/07-model-loading/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/07-model-loading/wraps/glfw.wrap b/07-model-loading/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/07-model-loading/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/07-model-loading/wraps/glm.wrap b/07-model-loading/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/07-model-loading/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep diff --git a/08-colors-basic-light/.gitignore b/08-colors-basic-light/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/08-colors-basic-light/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/08-colors-basic-light/.vimrc_proj b/08-colors-basic-light/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/08-colors-basic-light/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/08-colors-basic-light/KHR/khrplatform.h b/08-colors-basic-light/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/08-colors-basic-light/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/08-colors-basic-light/LICENSE b/08-colors-basic-light/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/08-colors-basic-light/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/08-colors-basic-light/Makefile b/08-colors-basic-light/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/08-colors-basic-light/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/08-colors-basic-light/assets/popcorn_model_a.glb b/08-colors-basic-light/assets/popcorn_model_a.glb new file mode 100644 index 0000000000000000000000000000000000000000..ae67d1554cce0a5fe6a4ea2b7c9cbd9d5f765777 GIT binary patch literal 18084 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 literal 0 HcmV?d00001 diff --git a/08-colors-basic-light/glad/glad.cpp b/08-colors-basic-light/glad/glad.cpp new file mode 100644 index 0000000..c80f1e3 --- /dev/null +++ b/08-colors-basic-light/glad/glad.cpp @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/08-colors-basic-light/glad/glad.h b/08-colors-basic-light/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/08-colors-basic-light/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/08-colors-basic-light/meson.build b/08-colors-basic-light/meson.build new file mode 100644 index 0000000..a971022 --- /dev/null +++ b/08-colors-basic-light/meson.build @@ -0,0 +1,100 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +assimp = subproject('assimp').get_variable('assimp_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d, assimp +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', + 'src/physics.cpp', + 'src/mesh.cpp', + 'src/model.cpp', + 'src/camera.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/08-colors-basic-light/resources/textures/awesomeface.png b/08-colors-basic-light/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 zcmeFaby!u~+Q7S5EV>&cMY_AY1nEwtySrhLN{I@Bbg3YqfRyAy5D=B_M!LIe-O1kj zoWt4Y`#$fz&-qgxmJG*y$2;fvy)njoCsSiI)b3-U-$4g~Kv+tOa#|n|7-)h)sK~&N zL%*SO;0J=I)_ob!haQSG;4f%yiiVyb5C*}`2LY6xNeXnLcqysMqbx#5&@sURme1*c zE;28911|-8Cudawo zmjXEgh}BXe_L4?OnuacN$={H1<~FwEFz2T&ixe)^_%a0Up-c z0ctvy0gjf!R&Y_ z`kA|Na&vHT{!=qBPz+!qBI{vo?&a#C|DKEJ?&iGXk@hoXqfcvU94Pv zJ(G`KOZX>j|dmnEhT?S{!NFftChWt z|6e+IxY)V)*m-z$xOqf?Z!YfJI&Mk+T?b%KD|0XN|5sXW%l@TDjPnNaE$Dw(^oG~p z`hR5%E6ab{!p+;m=?{}zS#nxCSvy<1czFW$;Qn`eSXqkLxOzC7dr8JSylCap7=jv#o3wje~K|rFL@sz{Qe5( ze?#_WkTs*zZT`aAYOYgBll{LN z;LqNFx63~~^lx_juVqy)dz*hPrvDawH%I<6SKaiA0FDQMF#p5gK!*8`zJET)pf|mL=6!8oD`qVL@cet%t%?0{NW_|bH!;W04b1I-Jn}z| zH2hyj-a7JsV)+vmuptBXf}H={4F0<_|1;44%Z-0c>A$S_wz}UZxlQAj?ccb5iRiY# zZ(O%&{IdNU*Dn#>7Wj?pHjQ7lf8+WkqT2$$aowiz%l2o$#FwtwULC8FB`zj58B@yqsaT)#wgTi`dY+cbXJ z{*CLGh;9q~#&w&<0>5$Hrt!=6|A`CzU$0kM zy8!Q0`T{Rc#y}anffp}HZ(iKg{_C|8(BIw^{rj);p>)GTQnB$)eM^q z?mavWA%RFkpfsomtq{7?_&T(&hzy9#QqOl*>Y)9$kw?vN-?7{c(Ni%ZH|n1&*t0v2 zXYn{@cM>GrH4v)6fzYGoi!tcLP7G3+Iu~j<4Oj}-g6dvhyY1Ker%#Xn| zsI(x+&q?7v#8dG;6h-0)>gxPlw5`?ooG>h@H+%_y(1^2|!<^INOKq0N3{gP`m#7n7 zq8LDilm>4G-#z~-8#j>im^jZBKY}wz9apITDb)yq@3|Pn#s1FCEaX1)!|!pCZkaTb z2In=+AQbkB?$YgwOei7#asB2h9BwFXVzcs_as4Duhei7^8)H)vb04J3-^}i(H0`eA z99uKSJV5~`L>sdaOYCV%qSPPIQMthceYEw~>ZYq~+-CC13WvBxm|-+eK)8`KnqaYc z-eZfyC^vjWRXenT6k4Sx5Ij&gF76LIj_U(F5*RL-g_+%Rns zC=!D8s#-oX_P@YI3r7V>3xNa7h}}f-+d1V@NsB-n;Nu5Le{d5WfZh+gYe#haWfh}; zljxLn7x{&gB5>JXxRC5P2AmAHFt{0zH(OR(5~P~=VgQ&=h@uhTa!+^BXd#&r2yS>r zM>01MGuBBksu4%p-GN-N-($}$MLv8&M!Q27d$YW%d*?zO14tThwCNUwJK z>8Dj{KcF3QD7|GGl?hQ33y8?x^dgAzC&p)2c##zUg^{$J)SL8&$P->WJ>eOU!oyCs zs(k1)7B=T9kz1g>qnAf{F_!M|_1VSh5qb@=V1gc_LIif|q_Xb&tZ0U2Nbe&c=p9c+F;&*5!LiG!qeU&u)@ zWkwfE`p;43i5zdc-h@H;K3woLGCCisw98%@a=?5eE9vQ=-30xl8m>=C~q!| zi%RV+O?An!j<9{UtF<2WKhRFnZp47GLDHf6P#7YWJwD*DxIL@Ty_VT0{jbHv8|Vib zY|-x_zt$WOPkZqJ&1)xJ$|f6$XTGHfrA(i9hJ#Z`tZ%vhx-|TbIkBeZX^*qpX###B zN}MzS7IMy5AM?bn+o#-_u=ia`stH+HOM1upRa!N@9VEtgguTA@)QESFZCUIzGeRbU zWafHlA%Kg@d@@J=fJh8_*PJ8Y^s~1s*7A${+TmK(x5&ISFIKhJu9~#x6md2n&6c0h zdbKvIl#g^0?=Jb^Any#4Tr$8nJENm65bVjB=s;6xeA~&=TLtO@^jzN7bk56!|;EC>AK5rw1SoF@UDUjx_5CX zGkb>igjL8h+UCOSUlTFfa|AbFq-XXmD;#}uLJL$6Q!0!J<4Yn=9^15nf3O(|@qd!2 zr}J_DyR6e>KjD^4E++eEG$9o}z@amq>^<%5D?9E>cVfgO1#52aAOUU0WgasPG5JB9yne zOZd2eU$^$Yh)anO%f~oW$x8m7Nfz}Z{l)zdI3L%Y+;(HknVy`80W&^83%r?dP#nURnEMyx)1!^7*0jn7?ohqE zO^>a^$3d#t-K&9%PqO={xIwXx!gO*--2$0s{hrA0Y%Wy$9v_@V%Raxx^35e8PsgH2 z#wJ;;X37L#BC+SG%aL6t)7`V}-tL%6dzi)}LE?d*+l^N3qmw$C8lZ=Jd5F2{{meZ2 zi%^lP_0vg%{9Pb=HT}CdD;~11sX6}2QoIHJv6EgpaqDQRh z$@n0K;!e&7_UYn@+~EY4dq${-%3AWuGRZ_J$l}``tYt7*&I<9%{h5#76p6uDEn>Mk z0fs<25}iWJl!eq?3~I;!5PeUcnq}PjjC=f06%? z0V~EDzW4l6CK4T?K#c&bAilKW=(pcKEp{~T;;=#ad=cvt5O<=kp>4V`{G^n%aMAwuMFN|w69Tii7Y4(m)J9AX0126F$!aZ0fYHxd-u1=63` zRbxJ2}Sut-dikP zOc*XJ6@m`?ce7}u>TloLdN&t$5?z+0tPKJo*sf@e2vaPS%s|58d;lGVzIJK@@|;hoD6C3**-`i8K_)s6{NV)9y~oc-r3!JzLSEx*8Qo zH*OngzFATDa%Ds`A<#ZyQmC#Ji}~t4=eJ6?4J^dE&HR~X4$)V7?EZ;zM;NW@k)TIJ zZ5d>`7!xX2oa+ z^5Sm#Xj9yY1w5%J3Je34paVntlS^xYGL9LN4>^7)8ruiRz}74hmkZ~V064#-zZOU6 z#h}}HVs{in1MzrS>Rkp@N&+woIyxakI9PdR?ECadNc%+DdaEvkub>_2tEM#I-neI^ zUm1UxTtBQ_sDrDw30=_6c23wPB{zk;mHO!tCQ;Qhgm-tra>l!yL&v04Pw5F*5GSB( zEg@^4zDjed;^Mu6^4p<>w0=7^z1Wy(yuL)k%$Oo#F|N{usXaYHYpvkyCEP96u)VKI z7_GMUt!#zR!Z*P1!rH)kO%>6}jz|Fp!B$*}0pWsW@9r``3-_7gWFzIFNzl)^)4L>y z-SPT9#=f@h_y$R&RDpKOn*2M*dmNpuhr9t?mQKWh-<^|F9;?#k@l{1iSN7E~NG3mx z10^u4;*MmZiaj9RI@t&d+@Wag9>szl3XM6w%)AQ6WocxIRSTP^D-ZOWuXsPTSC~NI zfL^k7LTPs&!l?WhxRlEU>8e;0^M!qC-yo9gOIZIQk4a|6t2&oNS7zvkZF_-c{853n8 z)MSTnCeWJafRhZA;4}11zZa{$L^|mBd{) z;&Lh>rYw4}RNrchj}-$O?NwRxCqdU{zL>@^GK~qkvkRoVFN932N_w7JaJvmm;WJ>W z+AgF%77-2WGskmdDMwHur2|WuF&UA~stI0`#V9-qau5@o5~gV1k{0iyMGJ=9ebI#Q z-i5FvY5w`RiTfk8?jvl8*}ivckvMVCG`pop*t4hj2)HHj2-!F&3zES>0y{ANm(LlA zTbmi)`z1oo(PS0_5r^7lK=%fhUvj;^kDv3QxOKvRDSEI^P3Q>110@>JqywqCa-z$rBZk!Z%Ed8)rkP)&MzO;KL>;PcF5oZ_vC6B}Hghtmk?tOKh)!7H z!N8#vScw)a2l|3Oil9H(WqYZ9C#P+o_N~WMWYE~;ll9%N#iqCx?c{xnautE30`JK& z)Ou_O^}RPs?6#cnxG4OzMHC@YRUS>QN3-ub;3Kn#wm&f#pS>b}Y&25(9+Qw8xNdFQ zmiIEjJjBZ?mP^erIcFCV?AncBk3j zO>rZ~WTgqNy|D?CvXfR$tfbs&cVM9)+m%f;D=@K@s1!ts@D6-KWbpKaU2VR=x6r-y zUAs|oXo+z=j0QDbFjo}=cT=!})wYLeF3!7pvur(i=n9_zh>iGAnl#A*R^?gYn9P}X z<%LT5mq^m5&jqCrIGMbiUmqzg%^xV2kBAsl=4tbw#-idP;1Xq`URLlXz;{ALp`F>H z2;%4tb*eYRgu+pG*)i8CnQX)dms9&#MV|`JPS2862LXN|R5foGjtYHZfw?PZdk3CM zMg6_HHUXMWJS2ib`eh#@+>H=>1=G%(+wFn=a`vn5-(Knt@kNRyxG`u%T453*;F`xH zXUi+^6YP6l*R9z|1Rc<+8TMfu3+B~yg#dG;+(TwEvi^K7@DbV8qpQ)PCRn?-Mtr0P z7ePEsyv1dW6c6-MjdM;{gt={YH{@NZQ2=^VVsF@hf=(IB#Z@@X>0K~z8}y7)HdScZ zv=5_w+2Slc9T?pfHZ1khD;^c}%a*4O*Ek(T!hr7AJn zF&KYrOV2j?%>>y}&-8_$vvQI9k=wmcLo4kec$!65B{G_2aajiYB#0v+j6ES%^z!}u zJ_+P*`CmD`@@z2TN9GClMX_vvPC2FEgTPsHEss4<0`Op*}vo0JD#AE_Q_eY%8dn zOPAKLeu>{4P7{fo7(2j@w&~I%?kmjMq)X+1XND9lRpd*Xj}wC+BruXUT!sB^Pml$j z`q~w}GIUry?yy$*HNg1pyjwF=?w%*dYE0qh&)=%6^8y0WU5`Qqc9XrLQK3B+WJZw= zN=(%07To2VTS=snC6Hr*+yJ@(z<f@EZH=5q1`uA3Sd%3a!3Vv%iIvlUFqOxG}hv3T+bwIuB}h45q-EAqK% zbru{kT)QX`3o*O!o?X;rg6B~H|E+z{H9C3*J% z(!c;53S9xcV6u-6;d*mAb6B%ENO&Lw#zpB+OXN3|7HiC}cz+bV>9znO2h|mC?l9L+ zEb~)tWc|a0(#a{@SjNILOt`R}{Me$OnJ8Y|fW&fsU7AeIj^y$uFTJu?G0ffZMm9t@ zjsP(rM5^vW!*UkeAF%3?c;i@fa<}5WTPufi9}kMaCfB9 z4DFjBBl&we2AJ2av=m_;O|x%yxA|SE$ujTt{4pS( zFAv4`hGF3+1T|WTOnWTIGJ|bE5w8j4K&Rgkr5+T;!=c+srRP@2Z!wcdL#1)^??aM} zlsHtZjvg02OSeNEP6A43;rMTW0ba>6IpLUH&7tleqSPhC$UIYphO~gBN+Xwqs-fX4 zm?TJ(WL>6?rMtXuk%RgSB25btiKIG(;%;4#tQZ-K~4F5T5$|9=m@~0p~dYj>51xh%R=i@eyW47A<|E5(kTx~O{Hq2 zmjE}C-TR`F+kSH4u?E5e!M+5yn8`fb>~zvFxVrW_kMEJ4o@QFQLF_` znmwVX_W?(V?57G1i66Dyv!|!#si=4EitoVAyWhnNzZYH4MrK}NMU~l{)75;T+DD&_ zG&r*WqmHJF3MHF^AcI`iAXwvW*H7O>+RcXc!#a4DtEe=VOV$|yujAG0Ol2=0?<#Rs zv;L8Ls3CUbrZHzbfItfh`GHOohP!zo8FZqt{73=>q|D+cI0`pQN?ER6ZJ2cDi+0B6 z8Rpn8Q56+lKw?0rRQJL*HAvycoEvTYz6p`&ti^-(fNe+QSbJ{ncJ&LLS6>+8)LRMD zg^Jpg!qML#%7I9sE2v=`q1#GlmuGwKZeL?3mQ#WOYeFKhz10btIu{Q{DhXtdbO?4o zj7bV3l}F=JoRJ5ch)@T4p^u3dd1J?%0)_NbVx%|Y(p`~YEfW`s(<+uR92Hs7JATBw zRjAOhMJKa6(h~crv-D4^zuTHU;LfA6dszusA62pnKG6kgi0dyT@-*|LB(LRO7sfnlJ#ws9%k@p92#Jcu22T^ zAJw^3PIy3?2%p12FY>|RtJ>WiBoJy2H7d_Bh)=;fM#Ka4KPEe+l=iujyhz2vd^Lbo ztrHG7JnqwO5oV(q!h+VoxVO)e%}}FInP?%yW^IbL?GVQ>j?X4nrfx=f7_*tkDDR7~ zUHgpm`k5!1jzqXNT5=H!@{#To7uST^2*rNT)^+p${64%5QH|42cemIm7%csyUA{1% zENf>u^-+dp0A+6YeWb@ECRA?kCd6I{69fU)QMyA7w`F9^K2R#p(Th%@v&%(=uA0&A z%5mw#gJYA%YV5I#az|>A_*T`q*IF!~boWRx=X@L$8roHjn<8v7FiN@;zHhag_5Jh; zu&cT9s8)`UzRNx?XAvI8v1W6)X7fZ)D)SLJK0Ak~G=GP-o7F+DXLzAu7Up-aN+|C$8VBdcF+AFBq(W^z*(?ii z61JC!oo61^M{Q$ETi^r_t@W_=YBlS775uGP6B5)M);EVngx%^JL9gOPcm{vGE=>Qb zD5(9)HqX}`-~Wsl`A8+t)*WBTpV)ajoFSh)Yi{>R>YTw|F%vU`A}_c5qJ>_FKhv1{ z6hbCslK=s?E(m!MGI$ExJ$arP*oHeKeso=S*~Ajt4iYBbYSOf^9$w)OI<=>F6d2kY z7R0Kms+XN`TO+gS!0NU-{vp$W+51`_rlXiJswYzIq?3k;oH(U;xeNeX4Ulh{*!G#gZL>{UzVCEH zBf2SPPxPfVb)Bo9QQ>&MXS@0oJ~}Je5=c#HH5-<)OGXzERUykO5aG=I%F%siX zx=+BrBj=q#?0CtNNa|v!3n1E@S_rvcvS-DoXPGePm?cd zAfJTo?CjN@AK<%FR_&iK)*O7*o_ts85cgG~M^VsoPnh1s&&KyWzN`O{4bl6Fkiy3A zk!FqMIz;&K&nR)E+ES2H*h=Q!TNAN8)RYg7xJTQ3KXIOJ`N!tBvx9nGGp`gMkHUPS zYE_=cR77R22-f|)R=eau)%S|LgT4WKm`GIUR~jq>0+j`Lq2q;TCp_Uk`$kLb^!t3T zYN&KCjQT8EQt}WBcrKIwwx3g?HZtSGs&W~3U7uAd+Y=cx{R{MGWGG5DLl4N~B*nhM zXP8&AaIgnRr<&$+d9S{Rafp^N7Umd1-nnZ`hdX%2;0jGx6yN7rG94PQJhTwY&Q&nn z23;eFae!$q4IigW3Nw9x-woCpFW>WWhJP6MKa`PtMATjs0W6}&{O)Jfj($t;_lq)< zkdZ#rSK*w@2)v4HC1e+9<@g*P4vRJ&o@x>%e!{D9=1qw~@^XKQ_08rOWiaz(XZ&ib zcj~dtOr`}pN6`R7wOmM-pTF+v^PbiV*kY^kD9VMqXrBk-r~G290w)y}P&Vesx~XPv z(3ZUyWlD^ZgZMf6=$3p}d_I>VCYPX$-vO*{MGe-Hzi0noS zU4bfgWk2-^zp8_ho^Ivn?X6ad`Y$huSB;Bn!jB#wsxOR?BlEaE;-ygFp9zVq;b&DmxyYpSV45Jgqyq|H8I4%tq(2A7W%dW1nU<5v={|NN=&< zX^gYj(WOfx_ZUS|hmGefWdxaUlj8Sw&EZ%Une)efI>|v8?7Gf`m?2pm%efqVz93$x zI4!6(@g$fPo=XZRQ1JSh#9t`mOzu#!@|Ar>R})i&>4EuZ>Tss-&j%we9}>sU(q5R& zJ-@i`HZzQv+ZASHIeLr^`Ps?2&&O+JP&A>_Moo1d-I+5A@?2t4;<}hn{$bP%FQ+b`q+s# zrKz(k=19^&5ExWtz`F;EM3ct4yjXcCTQ|SG5ITOeqgj1*twV4!^)Xu%{!xixIgzwq zGGWv-OGO&)H8ilidM7MAl(ja~Pm!P!pI;eD~HO%O95`6p~!9J?hn^y*x>x2qw8^}vo`{1~rx{~r;1}FTUZSObyA1tdh zbSd%f9ZGg`FZ{q48j77*O=b^k3;#&>ayago%jLTBbC6b=IwX?~oO>`1dX4OO6l!+0 zwusX`q*p2_*fsSiIiF5URZT4i&b`A{hPjs7`{T#!PoG|GZaSf(qpuFU!LX?$OT14| z7@I$L6!5O3q#!?ke$sSlDa)5o6XkLz4edvBc^L$yV_sS0;rH;f8#%4i;x;H=4oL)xA;s_HFdQfL3vF z@mQrT&e2g`!cpDcw~))N&(9}pCu~In$aW2+3UdkHc#L1-_<3j=mN$X!fgI@s^mIh68RW6jn7)I5x;s2x$cN;(io*jPenth36W5=Ro}xNg)=rDpmu! z3U^;vIDcJk-{w?aUtMY<>B3watCgwfDNnAgZrEDS{+ah$Jm7F{NL$@{`A1qjwIo$R zKk2UR<}57dWHvNMa5gAu>3izn2ywdZcqLB4y#6RwG@>dkIR9l^=S6*?R^9t--d@w5 zZ@7@NwW9!qM5^xBN=c*wPNW6*6B$@pS?Nsc>g&_#l~Z;HlsPNB)&_DVN|+e41+PV; z?k*hAbIg_Zu_;-eDT}`H+TJ${M0krBC=ZIv4h*YAeX$X`Fv-a6XM?xC{WhomdYa{d zJO1&yUUYnL#@13zZqVl>b%`_#&c3JS*tuut;YF#?G_Da~3p)e;zgn&UM_kJQ( z)(oUXzij#XVrM1GcLr^OH@+o*h0$ZeKiJ9`%hda8D`8Le9u+67R`S&&Xn@%#RA^s5 zVhujsD4gCi&flS*Z>R~&=%|^R9R2~#&v+_6{SfteOlkYYaaKI^m;&IofgMSb?*jjM>Dt z^g79~9+4A{!teQF-hD@hSY5pJc->I98ttXU@;uV_Q{dklm&y?hx%3loo%vC>l0CVG zWnygn9e`q3Wv8i_6S$xDeeBE-=|N(0PAuo$)_53#2Y%hoGQUaSN@^H2D`U=&_2Cl3 zMnCSsx2hNy40Z793oeP}*+pbA*cQ}aK*Us9svRY&G&n<(D9ll9_aIeq|{v_wPmQsajDFQ`anpsaVRNt8Sqqgp<-iF|9zAyND+m- zmKOd_(+QPrrn|xz-!>X!ChidE&GE;w;)I$Ab`|kTlGyHdb;xpvk#&10@`Y07EWP68 z&mFfXaLbK>4B6Fqbv*eaQ5y;=5Rh6T#+B5Q^S4HQwZ-lBprypEDg69k$oFgxg1JZ zo(pSi6azfHZTII-&w$0tgWi>E zPHc;R7gflq`ORlwaPVHSFjeT~-m`|Q#4pCmI6NQkgT)yMrJBT#AyDwx)M}j8YTE0S z;W#5E*SjKIuV^6ftLx&B%b)#dlI+I|!zS<@vFewGsUOh4R-PZOwGF&c zW@chS&4>nd;Nr&_%gW}P(J{1 z4g_P7?|Q-?^8CqdH$&dRuAQ+JM@HNu*%>oe&^J@{S6pH3aU@AE zUf{cT=M}R|H~88D0cCzN{!vSHb4n;98K@LD32=QGv)V6anob&TYJ8EMG>bK&{SDgL zr#19g{J97E95sY_A5LA1DU+IWdGMiv5Tkaw=`KwN3`p!j=WB)L)|b*4TIl)cA--a$QgJn4#~ynv%IxN0?$ znHcoudv}E|k5pmHBUbt(^iO^+?&aB9m?m^o(3aTbT&t^%!Fy@W8OzY_qqgBU#lS|a z-1X{iY)4b@k6yr3W2?qb~L zec~*#eDTn;n_uj5w+(NS>gCIqi%UyUS1XM{(!SS6-*kk=;@5XOQuMo1@AlQhq8iOz z%^bZ^zGLj#&e`vQC`3bXM%LkZ#>mp)Xv61i7Lu`QC=7^#v+!YV$u^6Ma;Nc+<(L-e zsSA&{eumGM_MbD%Kyi`%bePm^+AgdSxUU6g{4C|jL!ql3^^Vd~K8I7E5h=fe&KUpthldTT!zKE1-P8J16kWgqU9j!)4BFE3NZz`=Ktzo2I5Yu~zf(_m zf4!t^`T2dSm{o>%@7~=N6&1~wIM~+ZUE^jz@mBYA>SiQLCM59F-A8FwkoVSL$=L?E z$YMMq!GY$OPyu&Ev!Q~hKahuVGSPHDTP@CXJ{2dJ8B~{~OzEID``H?WC+J#s+NL0e z@}BA8JRMaouRfLnC0)DwI8jOB_$jABIn8{6WDAh~NZfP$m;G6DyAxiJkr?lR(2ZJr zQz2BJgzXCX0}ANhW4Jz6d==VUg4$XE>zCyv<*g;BD8I6jH0-L@sGkR6z-v#&Bu;hp z-S^r_9y_-I!BGO7n>;;p%I75Y89wJ@1QCox^r)`JgG1u%bJKC|X$K%tH|~F9)$C_` z&IGDSH9XsTS#p;jyFEAVy?d#C?zfJ#)MIP2om`~M^e}T;(4{51QQ8LdAeB53G2&54 z+Lf$1>K+4?zYEEX`_x#I(bM(bj)iY8#EGxZ53!GfAE6&+s1hAH(T*nfz(gw^w z3Z4w$TI1KR!sQ_>z{c-33D~-GCp~e?Zu14b^4G6lpTzpa9G+Fp2|BvzPHKF#bYcY} z4S_YOm)-oZFE_s3f(C7s0i0`jsK8o5dP=mI&>6N@SQ4s3!~3*XvczTw0p80y3)t*% zW0bSB^C}vPoHk&l`AUg?;}L5_E8QMA5*ZvCXXlh2bbS}9R_GrUv4Vs;c{Sp;wMBv|vpf4LFYW%+#eIas&J@Og z7AV40$i$-1NqR3McC1GCE*KN+aFQ36%G3CsH7FEIpldmZEj#s0Lz zSMcC$6P*rQ_#~FRQiX1`F)&H;g%xkxZ?8(t{1LQ*U~-_U2o;*Nn+4!!dWdAh367n$ zildR=MnOc#EWDk>6!T(l8@QDMb{nVu4c8k1DVMf5i}bN1G^=2#s8YFXzg=>l)XB@{ zgnXvU6Bs<9e)(N#X?*OC`}R?eY$XAGH-&bglg?ulOc5${7d9ya>`OO7kSns~k>u;p zJB&SB*hK7-IZ7P7Ps>I|v}$1OWf!JC6A}_Mx!prgM$7WLnIA#T z%B~x}41O#Oo4wlF0A?G<*{rCir>DcOZfs1Bg@vWL_wXBbm0NF?sg#0@Q`X0R=JMWe zEo4!dLIO;66tQ9XZdJ8EkHat}aHLxF;l2-tN$^#RoF!GSia?}TjZKZMWr4uG()IZ$ zOyP?`?c|nFR!`BZ+SyH~`G~ehAl*igv^J>AeagRA-@y1%JwwE@1G7isVzbDRGNW4o zxR)9V%4wjQmKjdfedZd&+?&3>4@UPjrK~z-Coq3S$u$LO*#dR}Buk8L6X8@E!I8r- zO_T)Z#)FDb@Eou^qX+)mDO%+EVTX2`O8M?DO;_;d{zeeP9vEVMl#?UXKJkFc=+j`R zt}E9rus^tOO~4!*o-fxMFuoD>-NgvSMi!XzUOPBG>*0@2cn`yukWd@GaQz%8vsa{@(b$5E@pil>Ku{oMUR2b#cPVDzSqDz?Sphr~@nF9ILOklUrFeLBHd|z{@_7w^U;bvoaLF>{FQpi?m73^PUC@Eyn^KyOpnTO3eB8a z@ynkT?~Rb|M=T9upIzdD8UZ;y{0H zH}}<1#S&6cxkqcJ3&p4)KdCwwf;ka0m741hMzrt?`1-*EE-&S%j-1&Oy+d?Av7k>M z7oP6{8Q#QuSQn4KBPl6KNm)6r*uTL`mp?E?SLTDf0|er9hVzB2Zl&K+bpH4UZ?Bv; zFIj>@Y;0`)cHsM~;-{Q5lQ?G;FWt4B52V6lL^*cI<0q*l@JUHHW(7?k(5_J~1aJ5T zVbli4IuiTSdy`QR#BCndoYJ*Vpie-eS;V-?@d<=ODA4tUscl#(eUU`gO4w{n68?0RvWA~WBkWM-)SOV)s&Yn+gJMw3icbsuV#5Bd<4Fv z*s3C|Qy84T_T0PN{_Gcyh8j2b$_*FPiwik{W04#o$Ds|c3GatK;OR4Qu)ca*k3HQ` zUj7V?fI)8al#16zMW<&H%lOXNo;{IOd)(cVlWE(5i0Sr--t*9H_;Q9TgM>uQx!LvQ zndVtjsQ^h?V+F~81sgXmw5u8%Ob^~zO~T@2_WTF*y77RE-0;+}blHOM=L4`;KzMu)F$j*?p;{(X zf-)8=Tx`nCV&+>>6R{1K2tJpS>(420pYdOjUwX|xJ=$tpQk<(yA%jw}npYpCKQq2^ z!v3LQyZ)7PvmLAFWpH+&W7)D{9KXEDa4TA&*BfJL8LsSSs9p|QDLsTBCtMlv~J!MFLszW`8n&~y5q{;hf2L`_`%B*q?4Z_8)&i~S7 z4?Tvh>GY8sG?upR7@GhEJMP)|{`8AEGhK34eH|G+6DKssEU1R%znKr6HHJ+QtOO~2I0?e7|$Bp3C9?=5uRpPu7jV_O{7H^utiJ5pH) zf5|Ip^bm<1o3Kd-Rcw8onr7zfMM?2xbLZJg4kwoX>6_xg3ahRc<)Xwwc6~J2LHkPA zS398>-oe)IvwBB|zGMTzUTmDk!=H1x38gk-MMmyO2YpHfHNXRj7`ZKidio>aApCf~ z&024vG5Z?_5N=-S&FK|CnIh23S<8D&WwA9;9byWzk)<5bVx@~AnOk*5K+1H{D=j(N z*hfG_?yGe*weQ^NFEf>#358#kpNY}a(*wlS8hl8;rSJs8JT%V?kW_m?v<1`M!3rPj5fmGd#@MdIXyu^gu<$3fP@%inh4Iu8zx< zX3tAZuVOboG&}`%%^dZsw6JY+XZOnW@3PNm+rys5wnHzZFmi(Zzm|P3IJ&&3;BlVd zdla};tp=xPi^j6NIzN(RLcAV@o$Ehy>Dp&0s+DDXJLyv|3_r|G4iP{IjUhtd3ZwZ1 z?-hQ-Dm1-?p~1f{(l|N}3k}uM(#j7Angwb!S&v{>=Nn}!$h*O=T?B*1Iy#h zamwb|4t6YxsTow}j9{b23R)0&`Q(a)W+J8{vIvesuaewx5SukY! zaw*-jR&@j}?{yvfHlJs}T2)fk{LQhfiTKb;+H*Mp%TLpBuJ)L2& z@Islxe6q&*rX+(<=08*IsQ&?W9Z=&u*PSzxJJh|Ee?8Y6nSVV zerDN>$U2jgH{0)SoOdNLD&O;g3VSY>2OK%f1fM)y?#)pL+(T+RBQx^{eX2?8%`=HA zJ3M;&t?wqjK&i;*)DZaf0cmGrCx(e)&pu~4lBbd!Op~B{qOyaLFKWZCA#NCEZZI8z z5D|<`pdJMp=pNd3qV>IbKzn>q?z1zann)#XalTaTy`cvz7?dfTraeFrJ+|A%@uXUz z;Q9Q#1%q1VSLVXZRwc%)$aV|+lOw??w>I?}l!-RpQ1Y%QL2MazN14;Kvu6(Z@1_)v zzt*}5HBmM*9GV4y~XEUyef7sx&cQk6M4g4ag0nPoo}>G%%?bmr!c2p$x5Ngi%WQkEQ?SY4@$s0z4)clk z`O(IGSjg3NlQd`;DYHMgnDJh}d#1P=gz>}(r zouxFNv#Du`mAF1yt5=$Kz-)W7EiMzE1C_-dp#{vF4~POArMkMh zs;0(*Ck-g0ziDo!%2M+jsh@UXBgO#AVT|HeWBPe@b#=h%8LeBQSAB7(toY+~2C^FE z|3lMPhPBZ)ZEu3RyHljNQ(THW#kIH=hvJd~h2j)1Qmhn8ad$#-cXxMp|8hUa_vUAk zot>HM+?jK(o!QO8sAK@}5f(CsvUIS~L8jml5M`V!C|(L%@pVLq2Fs}IrZ+zg{YZ3f zBG(4yHgnECpNrGP^z?yH6ukF@tO9OZ@^0?#unO^L?6aXK|Ci;`tk1XKz;})J6`#t7 zPsMP+QS%O%K9U8Rs)7YlU|=n3_&W2TI-HBK8rqekz4x>rm9$cZUSUgpM+|JqKl2ot=f3_g0v78Jy) zVl6sWc!68B7GXKfL4szt^3j|{QwY~}&K~`BD7Y~FG_=j(e0${8z_fUp4eYJ9x7V2A zb9(Hli z4o8r1aw=<~{|5x=WIB3cAr&ufyHIEy}dl%XKR?o zny|6aHn)rvENa3(^*kQ73Uv)PegFN||8 zG;DV6nbtlxBdf0qM+?EGp?Ue6-%nt@zuOpf9jSUQ&Dk@ro(Ti%Whs*+#`F`r@YsXj zYkcIv2SWimq?%&_0Usm&IiUtOu0w&TwY{^-WC^Q7+*pbrFgMn;Fg6i%wAI>!cizam zl_Dra=_9PaBU_;GIk^BUcYT}_Z_4n#*APF z8h%Z0iaqt}>FpgPqg6g*q|EO>02h+UaL}$H?GYRZ3x)eXX&hM7T->?VLT}Wy7ZLdj z2@MIN8d~EWtS9y$&htcYqWLlae2d=Q6`mXQeDuMU$KB%0%xC|09zj9<6>PKj=H}+% z<$pf8NJNoI15cqlgsCR8R+g6Xo85OU#U+(ei7eI#5Y(JvWl92ku1sZQ-0QE30K7-1 z%S0dRnYU0|`QNwX_InM$nYYMA7&6{dL~n(#$eIQ{<{INA$iQ%k<`9X-e_x&r(m6FV z?^@ev@ffNS60(W(+bjahoA(zAvhUAhb!14W#0o3V@X(&wkFmAv!>YQr&DjV5nd&J* z#JR4i=KY5a&|L&zTlKIDI_tG!l_pZrA&TMmI&uO5b4GMmie~@Lje}ip-D!;hI>7Zy z%lh2m;L?Z z)^$S&NJM3rJx>IG$D+nWJ|MX=yBO#IRic*kqM?zf?g;g}Q&vS)bHXnWV_6xc2xb@b>cEl|81ln3}7vUqGV7BP#4;>$fL z6!EApT(@y9 z2YmBm^)D(fKRx5qC$Sa;d&55s!%_S7jKgk`f93sGY3h|2kEizfk*TA>Z;aU)K@-?Q zy08v;_$?W!fYxx<`{Ji{7j!cstXP&ma+`fX{+rP*!8)nhQmJk`(>->Mn2hnLyX(5D zgzCu9)Qo5amvWvJjkV+pLbMN}g$q=&?z^MDTT+Q_%!Dm(et)HV!|lvte(zD0K#|`G z#pl~6vE4oL$IM3Ua!GY(=};DS)L`@523Jurkc!txHJ9yQDd#2OhS zdI6c4s)HFJXwu}CisA2hKr^!swq>_cvha{B{0srvx1vHqLXpK@xTp<(O4(PK4L`hv z@@DlRm_C~MGQ&ekcY@*!E6pW;c_Tr^k6(pOv301sh5C?3GIdaM8)+nrEvQY!U@pKOpE(3ZeTc4&+@%1uWL;LkIlhm}#*@I^z)`&7 z5s-_-5TFOjpgqVCdNkTG?6fCQrty2T!82AG((mh?v#HQ;@%!~%k?s*>yVTLk6QrU|T%aKIqBT{(NCUIf? z^lPvlodmQT_;0fLN6XFioaX}K;J~;vrd9h~LX!HHpx404Xcc$R*bHtkGlxORCm&V} z$#*P-f*N8gIC2uHQjQA;K!g7W_!_}`WhcDKbaw-^NAC#fytTwaQ}N^DV}x+fh~r?! zW*2bAV5<@kQ(q*P*l*ckuKZTi*Vi|)4V)&*LkD+f1BQkF%nD$rcjwb*Mg)nNWkQG* zTJdpXCm)}53#*}?w>doy5S|TVrua`o3HLbiyOw7wT7U$np1+yo_RiUL#V3A5PeU6LiC0o%ebLQ7+~nc+HIA+k8wwwr>Ext zy7-X8Ld~C?b}WP?)*prl3K4+!-*-9zD(8QC>YbLEE%bIA<|=acY=}nVBvj#{+28ro zPNM;rUkngD@S2t|S;i!3UI8CGlf{Ii9Yz{MFQtA1fbG7!zWbHvwpqHBMY@F`GSOM24;G~-rp)2eb&|7vD;0$ z1(W|(UNWM>L7r*9>p1CPiJ3${>cBwU-H_ruuBf_Mk`Z3wZ&nOjreQMHX4N6ZPtKwY zs`a!tsAPkpem8wvV$mXxN7V?<{BrE2pn4V)r1y79+=Oh`f!0$5jNrWSB0bPR8mvJE zFGe=X*KhR*o>3?*E@1+(nKkJ5lrm3c0h~@AuET@YL|1kG?B?qF%#c zguW__1b>U0Ny))0&DNX9xR&;-^OYF-H2BWuRAe&K^*!8bQ}c6tHZc{I4eWMwruRmK z?T;(XFpWqp=I#(IF}*oy50+R14LAj^4{gVG1vJp7d2I(rjlG3VY}RzjHIVp*723YPrq} z169GgFNL#I4?PpJvy920!O%qAcM|T{O&i?A&Yum&?(MANH0&bzGKf+F9-!>_{3m&C(E|=7XqYoMLGrpS;uJ5cs*7Es- z>6c|2Aj^aX7&=n&WPl+d5k_H}L!!A6)oM-&3WhY^qLG)X_5VM>if159wFolnmu zY>6G%D=A7NnJ5Nt+G?E{0bVU1_e@5bllOREVT zWJZcfiNWumIT>zW5lR=<>FSr;c-wd2*HwzjuU&WgRXAC9Uh7x&c)g7hi>uEGhmdrV zivbr4cifzvu$*dZBZTN*4L8L;Q_?Nmt}GCiQRfh5@dfP1Aj#8`arBcEPVvWw2pE_$ zV0V9b&e@BI{S?v2e)D8Nk_gP zt=Q$hY)v8w&Dpp|++V#69Qsb*kf?6EJJ0s8z85UQZl8$*)cGDRFaZv)b-6jhLD?Hy z{YVJ=E zOgkHG_z+4)gSzY3kr6f9PY3y?P!+l(S0f+?(nfcwGkqB|NTFYSa#`tZgMdVsv zU%Ek$?o5h$-#0t;q9=m7XYYQw#d(dru93}z(s>X6k3vA$2dz{?oG-cB z0V3k$x`PY*egNC?gYKrDf#V`+oqKAQ#qK+YqT6lJrdokqWSFdNnYVkM#deG2C&&0e z-Hyq1gR%JwYzz>4U=n$4X`atUSIQF=Fg&J6p=bPWmM~YOUyw+{X>oi`6{P+~yzxJ6 zjz6%6$x-}Om@tY2OTdQWu;Iy@!D(s{4?t4q8p?kPU&;cz{&N$PP%t&>fB$%^wsbOa zYtEq$8dE0%6cAWpswC0u*D!%|^uU4j-f#a?%}S=t`*-)4ZQYjmr+%l(-v!%*|2tL* zcI<03JqwUT2l}6dH0e4SGmR%EO5+cT&y<<+m~`1imfYvspwKiN#K^ z5d#0&=FbXXh5 z`bCcQf5tT;1H=@=0@F=BJ#zxWUb8jJtGuM|y1@T)H5NND>E|J^>HO1&W8s>`XO-|? z?gV7{{~*AEF!nCVv-mu^HGAqK$n>ue3FWXn<^QxPAtrGj0*@INgQ5R+A|U}GcK?5A zazs!y1jA&>FF|wq#b5wBv(+0Avi~HP(b7bMdmoPF2)bop^BXq zW9D|XW^$ju%UfRfrSe24RRMFDnRdDsFm1lIe!yDeLXxp1K#;_r9WjhT_}QjXaIO|s zxZe4guk+{wV^eD7r>Q9H$nU$)Z%tN)(xYthMNl0hldEl8D18yhg-fj~Dlvh%Q+NT( z+jnAPiJ?%l8}Jn2db}J%JvA~xzvkhiV1pT84R6WG5TZeToC_1DN|Rrr>SwcNi!U&m6gJHC1?!4V(y$7I7ECSBrxv&j z%4gD&*eHwA1SCd&HIH(EOdly~@FE}%*O0ksoRAVGITsl0kmeiT4WxVy7{kYBk@(R3 zCpbxAw<8p<)C&k={S1P@3X;|=S9wz0pR};SS4L@x1-drSndse$EljY>UIH4g@Q-|bF$%N)obhpHrV6A2|1dCyi-YnZW6kRp6 z3^YQARZ-OvMg>b9V(y)(*9MZrHz_k?OW4$je6B>q34891#4)?_RI#J%Flp3rVw1gv z7C-!%JUbIWKD((RJuYF(6tViiPgWujz|RP$SfKK8m1sNEs+RL-*2SvMEnVZ)zxgAP zy6?)rkwKjA{@IA%)2`n4v+KWwg;f!bR{kOA2v>T_4AeyyaVrbCX@5_ZllNdw@3ZiD zktTS}$CQvi83A!_LTm&@m*V%FRw<3m2Vs^>HF>Qf>awT`Q%^m@2w32kUE zxsxRxkdIjNqCK*B{8?lnj>KuC3SN_36Y?Y2N3PFcP~5)VWRhX3DTt~QDPKwOPXbpQtdC#(uj*4h*ruoDbffO?-zB zIUEtFP2)`GCccIU@jP>FgIu6BJ$uPQcqk`-FPqaM-^kgE01u&dr~D5US*1xm6MuOX zMKW6iLURx{{JQ!o8KKHgW*sC0ACb1gwcT6Kp7~~rq_2#8lFamQ4=K$>!Ik8~H_^i5 zzDSsYfDjXa?hp$vU!cO@D%Rs8HwyXAEsSErdhn@L#>6B#!%o@pdm;-Arl{0TR{A6k z?1}&&ayfvFHu~c$oWdS+I5US-bI;}a!N{3mA*m;K#mWsywcVqw&+nq4w4oBLF)d5; zn1!+AJgGSD5)h*L9qU|Til4)nHxGTZ&;aOR(8g{*`lSl&}fRc`#bb!N& z60uV{+0bsSL_u2$($lo@1mNmmrj|&+6zPJ}9^JS}=lm(!HCYe=hwS_3k*#x#LuQ9} zDDqXWIaOCsDvscxou2O+%r-g6l_e^M81l^|yOcgDRTTAF=pd#xY@ot$iYjl2sPx1W z>Dv}yk`(for+%E=;r|yTd$|zH)f*e98tBi60HtguJK9&Pe7@!?x=GGfL~lqFZ!RwC z&DSA?Q=)@qSp>ZLs-er7i7lq5XA9!=7-3nOqwin*tDjd-!*Y4co!q;?W1tp|GB6Zp zvOCI9mRjA~erjUvnzNiu3$|BK{fiZ@-mO0p4?ed-#mG>r8IJX8n&A2=Y*zMS+UXbR zp$YBOiog1EWK2;{?5r!~Ob*Wp;m;YX6-7kv1EBi_t` zO3RO~y1=G&SVJ-a8q6-4?-f-;*VFjhN;Rbc=nsi&L~>AZJZ)5$#<`~^i^5lOOd&w^ zD{!aVOt!R)W3gNJq3Aqy)hLF4ZF>sRX`<#idt9BSmRiQ^0yKRJ0?zZ%lq zex~0$h?bIvsg(;hq7D5-c8Eo+(XVGQu?0xIXEW+v6dNGn$#iDtD$(%_@W z-ukvMghux z1Q=7ovE>!p{@t(XEj!^bljkh(rV)6d1N>WRrpF&&9g}GRpw7IS3SwtZ8Bm8+?Eji< zUp_^YgJ|RwD_$%B8nfxLTt^A!M8N^BPc}3XyeO3+mT*s#wU;~`7y{EW3lUP6>-fOy zj&wej=rj)wrk-r!hE^dh3}wOhe?^zg<&Q zy71ty^7LpU9MTi;)4MKiYNYalS({|A%G{2vROM?b;tAgd`VSO;#UU4%cVoXO#0aZv z3Amn02(?=&--gnC4ixf=uDbs$rwDift7W{P_?|DBJ%6J6HxD0j+114o8Lj@6a59#& zw}{mju=z$4)1*%A5W?pogL3$2Qd3=UPUBxXJXR82gbYEv*cVkd+cbq9>V$U|1thm=Jv9L)#el*9>6})Ds%KLEV-nw-olUuB;+Kt+mo~aXx0OY(8mK_*~K!y== zm^SAuULOb{>)%=F&|TCvz0~GH=5aRrKgTY;dI8Ux_n&_+z~~GW^vpJe?~`9Hjh>j7 zX1;#xNA1y)A739qFh`@Oqk!EoV5^-AmiXk)uJ&Q}TgV%dp-|A|92kl&eh7Q$u1i-X zT|joR7RYoh-fNSC@(7;SYLh&BU_ITq`-hAXoMo+~jb~;&9Xu|4t_1H|hm1M_JJ4gH zuc41-G&u>*0gTuwpDf}ujV&252MCw|fbt(m9D+1^6~7{g$hZBWOyd*ucxOp7J<2!G z*&4qd9|2|?F$=hrfr3tqjtAe}jtY_W( zv;g^EkD9{a-J@X^q-28}fTI zJsGjx+s1*;fA)-^cj%0bw=}&&uOvC2nvemApDPp#SnI{|2wpWL3_E|9GM>C!M|k~o za|MvHrNS~B`9p+`9*C~_vzg1hOaAA=#$mkmW zXVS{1BDq9^l{VSAawnTNoh?$a+V6CdRt7f3ccClHv$G3yITb6qNbPMDu#-?CIBmB6 z*b!%7`%&o{$Mb&74Tl=}-y#ZtPcmq_q)hbW;2uI%+-jK3kX-jj*TQd4zJ9rIL7YOBw`sgC_JI*Su4$>IfpzUkPRVc>b$ZMU#dmd~}A!oq@(0 zUIf&@r&=v4<3`(Y?KXJHG)i>hZW&XKOhZ04av&LO#D4N{?^M{d2h5~))oFsW*Ueyn z1sV=*nmcy;UyBN0X#1p!QE$xCz9#3sur;lPg`+Ex2~+KEFa|?L)$odl1`wg_eyZdA zRVYaa^%bvleDgHWI1r@2MkNDmaY1MbO91h<@{qg3H|o0__dbOn4gHsgFc}%qSN{!Q zQ-?HL01h?yOdJM~iGc~-P#|rR^mi#AJW75QQvZZH-qz~rycG9#+FZoLE=%|=KMcn&(U1#H2L=*uG&Osk zARS`ekoJv4;7n)3>tj{7v1qxG2HZSq+iN}V5bEUsRnuIBYhVB5 zYYhG871rF*1bP$tF&q{si=nLd{yDoXTS&Y_fvHIM=hWejQA z17zeF#eCAEVIKo8GB68$_o+{pe&T{$_MY%Ch2R3O#TP)@gxX*dRn5=RqVJ6P%H>(0 zk_$XiQwq{BEro;GIi6*M9rwTF{S@DxL$pQJu|$+80NUe51N<@)mo2~CCLItb9bnqV zW2L%Cr-(Myr3M6v=)ok`BBF-~I~!_vki~U*Zt7AR!73Z$F^Ss2(K-)tyT1Z>FY}D= zz6^dXtKo*Ggz3}Vh)xbK-wNs^*N6BwKEf3Up%=6;8g2g~SYr`iLJ@P`4~JJ3fGZR5 zV<@Cp)ziXToOpIn!BRiPR4kB?Ok-&HU|HM2(!U|KIAXL6oDcB4vebjiQ`=t$tP9m% zso1w&-&%p<|8+2b@mihjSo{0zbE)&k5adR9C+dIGIT+=%c{@JKIPv9w(lDi$0>k z=Cdf64(_Mrrno+7i$?3F0TsMMF%_HVa7(Xx^^<;cvN%Aud!?ohFgWqFO4WjCCQe@t zBn7v@6B+TueRcmEX>Sg@T8I*sc^jl;=;3f+d(C4K>OS5~`cH^n$BXo+LxeJYoVp>A*v`8mE|8B$yp9 zYEO?L2S6lu5iHegrH~Pg^S)8n!ppagWHk3Hy8Xrhq1L+CZ(pET>)w)_XcE|M*Jq{WXeXA7rcLIQCjMhjRW+#SSuCfHJa>EW&bN87j#7w>3N z85zLVz4xX{Tv)c0g_>3Zn;E;^jmP?zUdG#(WS{MOM^0gl4=9kNnKAtJljgdrzi)Od zb@kUWXn~_mFu5|;(^qGQukw(pGX!Fli*YRW{H9_7p0(*#d5ewv7lNibV>lfXW8`$L&Pl@URo(lOubN2;CtGeffNNnXU}1>(q2MQx z#P(nKhn?wjEGi=%4<5tG=a#gi-{W|M;S!QX)ZhWBseuZHy81o-otiL#{b)jBW$mGc zxAnorK+xl#)QBDmwojP|CvQ_-nF^OUi8f3>LezpjqrpF0#S=+%cqa&pRV10_+{L$< z#5prMS)(+!(1PG|!DD!ZuP`J;r*%88%o_6}rFZTra=m7d?#S2%6-QACrC#mAUgYv7 z>BIIfH(Y=#r9crE)>?}G==8|z4WOo9X{u*E>vtpl={AUYSVXWE8{|tM z;*?b1mAL&DA)iU?yk1Vj(AZyob)hS;t^mpQOx_8Qd~3tXi*bTIN_WHKfFA^VT;w%+ zO4bZGq<;YUwVJm^>vFT)d3)M1Up4z>7HpNw+hOc^Nv?`m3=wK3TWu8|L4e&*4Nycw zFTBk4qPIt&wp&Zrjp9gOkNEs7^RAXd_}`y(!MFH`DSB|B{cP%!UA*YgMwpYFFNY>0 zP;Ql)f^ma<`uJ2aNH&!&IyV#&!bXoUBZeqDVo1*fY0TGEqAn`TjqCdt2e=Q4 zX6X#F{84skmYR0TJW>C?YOp6Mt>1W`Bf)w5e^gh5|3}k~%ImmdAISees@5CTPE%TX z!`*OCDuTlyWbm>dlst=2UEJ_=6z=2gSUy?!`pCp{DGn)AMmU}Qq9#BCt~(*$4PTub zKoa*7Iig@PCMc1Jvp!=h*))80!G9NUQIMD6%UhR`AHp_tIn8BD=MsUQcJsENLOIHa zUx_`LAxj}o-8%r}4-&5(j?tQ))mR>rXsAn<51?3IApOTT9eQYw94htp+C+ORNy%&n zox7i|Q8~qfR>9vgT8p*kZjE!igC=2|I6nZcORl%iiW^qbKT8IGXBPSBysiDK+U~O4 z9cey`whHX;tu%w4cl}9-kAh?j|>r6<#t#0P|=phVqnAoHTBGVvsDaLnT@+vf2$wrZ3f7hL?fGT#o$%y;l*&1Y_B^ivZ1h!s&}44o}ya;ZKayQ~K*ZOFHf8A&o^X z`i1>Wt3xEeHc%$^1wPhir|%%9?+#ndRCU*|>&s8J%um(Vt(BF-#W7}+t<+E_b_`fn zp!2kkelngyF=o1EbZ=igltc(wyWDxKVjcSap{cHZvetqT$?Lelua`Xx>n4F`0zOzf zlvcZ8>BP>CqGGJZm$pQSa;^7GqLQQEX0rQz_bEFh)^@%bjwLR59>=NWh%4}3J~h$! zGq4HevJ%#@dNFK==M^wR0OsxY@7Z^bF$nRvm`pIyAd0BE~NS)wMHx;G|)hCSm zU~$59j;r!4tr>C14IfeU*3gf=GHIVv)Zemf#hd-FOa1rtVw)b$$IwRzkqkgic>uwH z)dMN)-zwY(r{j6YD~N-jc6#w(PcsWpP(PKthwvty-T0$oCs&)pp zED7hXPi@qWgM`(4chjsw>%`U^`rqmc1Ydh2=&Wf4*Ozn+8jRRQ*0H58=qud=;5-~w zdTw_4D-OG3&^^7@UHu}aW?{jAd4+lGAjajkPxhyhhiY+_(&*3rPBjzE$NX(k>l9f& z1TI`eN4b|UkPRBi=lD@oKO@0W8m}MaUwB=HL#gXTSzWw&m9h#1_9GEE4gQ&NDR$_E zr6&(t`fZl@)!sEjqxtu_%rkL*D#>OfP~{B03*@ok6ysIqCM+mx{ISW=8h`23{=?n5 z`3pVKPbp(V7N<@+VWBXR7&Ggt`@}$|pT4y{L)MqsJU^jCXFQvI+pOY`9y&kWM20VS zzAF{%p9)Bb2!+iac5aroOw1CdGpG?PPQX32pF1Wxowl83z8}m(_T|-_$qgFV4F1h5 z=5c87GowrR44VXCXUNVe^Y1MI&xDZ8!AQCUlR(7_sx`$bEH+B?};e=GQcXzf!Raai&V!X1C1 z$fQvzkpCtiv~!x=tN*K!TkmmZz+%jh$P2MQJJEbD&X6AYBri+%(D$HMn=0bX4@L%> zL0#NBnSMfpvBIR~@1W2&)i5N#GoL4K|F)JONs{cj^cL+U;kvKKKROiZZ^wc%C7+L6 ze6nBIV$w-yh10fbSZ3qp1;y%-`WSz)Jo@*a40xkepftohB}0yNL0O^-);{=uIgBBs zOzVGv)c4))tYXc{y4lB8vo9N+;OkIi0eTUn_KW!Gux}7tvGc+_t{z#$qEGfaQ(o;+ zEMh)Ly=}Ml_KVi$J?6x3EYjwevK`Y2-eD@5=@ZKGhN%|(`5~N9K=iZoJ0m4hn9OLI zXmlLO$6t%h*Xce_)2|<6PNGvzGskkCoNSR@2Qkzx z|E1s*`Z*xY09e|6jk)HwZ%o4HzyAfwbzRpA{@M!WQ7)6PEdK?R@~ySGro+);cvQ{%loKWsm>Z_}Up#0fJ^a&pcKBnPpJ-JBXA890^pPXr8`sBMG-o}A ziwgM^nOb-bXx0iJ3t~hrFCXU~ws>rF>Kf10FcS*eN9}0Y#l!0E{z11|UqBBgt&zV8 zYWG44vJST#f1Eu8t@$lBJd|g9HPvHYc)iGJ58%4$j=9BwPH9Xypq?xctB%2Pbl1i3 z)OtrFZ;RCUgu^eru47zQ`K+c2ae{2l$a`QFv2D5fYG2c%9**8XFVYiU&pO0{(b z8~$F-euQT!YeCNLmGU&j<`FdelRmQV!PwUPT{&+P<$#dQbeevb%VyqO*6(3&Wiobx z{i#EuKMII*)7-^8>-?@emra)8;b-!2_ua^2(e3Jso{#g3dol4mUyp)rS%=$7xEas@ z+AB|@-zck~f8|;06xc!=o6q5NIcdkfW|2vdNy=o!`DV+VQ17i_p_LOmDB; zqOCkOE&2OjNM~L4Hr`J3HCBQuoxu7;l+Ue=cn8;PJ6ijwTwOgCPuBOCSCt+N=(le5 zee{@K^8Rz8Oet*@Hl(^EQ}2pY3C`$2@CS_Ohr3~&cs3yFDM80`iyhc2#DOwjoV}++mL`SBD#&D zrYH-wW8T5Dk+%_?*YdL1K0|#0k^ujlVyUo%#;!EHG8cPllrnR7pE^f15y$$0+G@YP z*OKaVv`|&+Gx49P?5YD4XEykn8Dfh~ZxPC!%+I89S)RCmDg_?-oqM=h!MW-R`f#kg zF+VwByWLNZXDoH_+bfTyiF$4ZWDlk-{%Ws~bmLCr?7;7*E7e}iO=N&7Fr;XJcYjyD}uwoh^08g&QR8-H)%U6lZ18w5g=dHX-@#h$qJqvql_cV*m&_x4*iw$=> zTZcUNOV6+eEL?Q$b>=SyaD?ghsZ?mg^np{$o`>|%KLi5KNwW3& zaSD-)IcKGe*Oz+>!QQQ^D3L1-y?s+@DzaiB#*xY{UZDw5F8X3YK{>eEA7lZd5 z*=1-Vz$XwS-u&~P`it|zNv-{{Aq2Yqa>y~xfb2U%yJIpY4wO(<$hIAM!?@P`dTwE2=(^7{Z~$ zeR9ZL*pAWH#dD&HeN%GfJ|)rd|6sJhF3foUaR!O!kPqMme3lG zSKAaDYQG+R39+qNx>n0YK!g&<3Fl%v@{V|5Gu(}8mBWGTf(T8h406HMDyE?qPyCAvj=W7uirW^!q%Yh;%{o;V7(xU9+; zUeEU5fE;vt$0YpYFBYQOf@Ly}tYMo|Aq31G#Y>k9)x8Mjpi(~n7w6gYY9uUWnQ{sV zMiPNxUU?+-+()A^ zun548ih{*@$LQKDFKt0*@nPlKE2z`w^^EIVPk(fD?vfKpPG|8C0&8}pbNJH2?5>3T zILqB?GUEM1MlEB<4EG#a*oNT25-5=OiP>=CMxcJ!3FTr4k0@U`hH^BeaDR282%)y* zzFT$W^-pS{{iRww$BpK>a_T!}Qa$jL5ItB~se0!RrI_#IgnwAEUKuY@=1fsZ2b1pb zW^$q5T!87tNNI>{0?nKLKkM^bHDABb)2?B^d%fEe_#qukCicpt+VX5&vI44#2+e#_ zl83h){6|Vr=-G{{ljVx~_;E#AZTI6p?din28#`!B6rnT0ZH)6KNruP^Xy*CG-#}+X z!mE35@;{8WFw1(yxldTB#q<6Cm3axcaB+&Utw>JVvIRx^w?Z%rh34ws4aCffBH)M@ z4;ZFT_awdVb&Kb{TP`0hsO2(Ms^*|;zT562Bo(1)8Hka6({i~3D}EdHm0tU}-og0L zvJ`t3p-sDn5f5rr*76i<+MrzE6GaM@9~dsc*mg2KDJU$;zhU*wxUmT7qT`}m+apVF z^~F=;UVxSVsmUo)LBmCuIIfzC!uGPKDTRw^lk)MtwZ#)XCId2fu1Q$&^UT^73sG(l zV*-5g!h<{0w;h+!2$%6n4F6M`n-=ezZCO_qqQ4f;EpC~`!{S^*stiBYb~u7! zlV^=%Tyw|~n=SE<)=(<%Zk$$nHM6grzHv zY_sj_`{C83;dX~W@i(Nsc$k$3RcH#HSXJ(mgYa-)BLIvV@8Y?%gKeZYH_MLMZB1X0 zC|i;9ezX*nv*NwjPPGV~ysqfHoJ5tYXqUr5|7>aYMFB;ob>Md@-@XVH3N^ldhcgO# zQ9jTef#hoSvr7|+#bZUIXWp}jjf?nii}AQ4MY;Gsbz%IW+>yuV7fmS z!njlY3S^$1@zw2#B1RfFZg%h@YUIr{PhV^d2W1sK^!?<)A8TFfZ_Zeb702#;Gk1Eg zQ}pom{(C>Q?pGc;imgx40x|=RHT5*z6X!7fG3R)fcP>0W^R$uOQQu$1#(o1jr=DKc z;r#D!lu^q7`M2r~ly^kKtB;IjBH3F$!x_wc)CV>Vt`f8mXl zT*D_@I6KE|i$#leq40vjn!MZCRIjS+ittb6LFvoJnh8gRA^uej|F5~PY>KOS-dyZnEy9VXNsLFqpV_gW@}|$6L6$sDnoezohpqIi7$<*wBu)SlGbT37SZy(Jl?;$nb9WfjVev_4-~+BE3HrDQG6AD62&QYINj#Yc|Efuf-x%=L{v|~C zPDVd*D*ABjAN+5kyHy}>fjMt3h?2mmte=X$xFQS9wZjCC=4WPBN1l6cZMss~-$o36 z+pl<|7`ilwe*_vkF68!h3E~2=m|NbuT|OcodPW=G3n2vWkrE*(Hnc(*3*H9wurmH|(6>`y z5U5qzfc1rC()#Y4wzrY(!d98WN$tTSurkrmCv-^Q2SrgjJ&}qzIrA0lzL$5el3~pI z4zBDU^t7o11XztXB_3qUt$E$zt$1e!ab(AyBld zx#7BLs?4PN{7dv~wW6HeYnBb z`!{T0r|oM#Io`;{-{;o97}tgbKaPUKFVUSB%ytOBk0myiN)4@s2<2Z@obx_#<(J+w7yhBKQJu74tjlbx8K5dnKV^2EjT8 z$JE_356`O$i(E!|9kslqwDrfPFrw7ScuDsrq(usPI~mcu-@pRvF!icxt6F<8zhn(G3-{yt5 zGzSX9ge9O1QqG-FHq&LXx4M#TKp#~~2%IuIq<>82uLGRba>{M|G5L)o-aD?Zee;AJ ztj0(QN9F=kKEc5_ZN{QYQuyXWkdYbxkwgJ_n&EIPfFX}5Z_0I{fQGKim3pP0?ivEZ z$?J942F)VX)&?G#^$x`f7fwNg?){o!5DJ!?>*<1&t(P>VN83lt_Tq-P=|G6+rC;gi zDt~8GZ=lAwDiH!WbCs|?h3!4+%52*HdOUT6FOFbEm4ITXQE?1EZ{dz~NC35d;hbYN z)Am`!G`|zG!@Z7f0^G`s6R_^w$91zBUdH43I{jsYVB?#R7A1$o5a=8C4y?A9yOx&= zVQH(+G`)~Zwsr3#K3CVS1YuaDf9oBFqANur*A_?tQ}YN~eUs!$ZG z=Tdrpi^N*?H91LZZDvT#49aN=$};BUE{7>^zHkwQ(0&bo8Vfo5M&C+%ifXt7ZZ1j% zKY;AqFHrU5mPEv?G8-6vC{5MvU7MZnuO>@L>lS#Yw4G8*yY&$aA%c_ERW=PuH%^kM z&9a6@bjg!&bRBcp&WjHX{^>@rUPTMZ zm#|YD9fR8Mg`QigcBQqPKrg8dS8BQ%-cYL>f1TAcXAE%Q&L=iAjSug8Kf7d{w6KJ$ zoT;zq{IWVwMhI1mk4?t*7<{)m{0?@-@};0*szu5)=mODz9XhAWd<8Oj(_tsKZcvkr8K1P1Cn~6o|i#4 zKCSl+fu=-fFkiL_b!XWtswtLHwxteh`}uIRz31=w9%EJt+S=ZDE~wOqrWpp$i(hg3 z#O?LBeF)ea`%nIu`hLk)@JYb@X%_jm=5H+pZ>GF%K*#mru#=x#O2M;bt02s<6IYm9 zFUI!U9I@!+w+Bp3ZjwQuWWM{tLB8wr6lr(R?@Kec(O|;uye2%Xi0QzKxxnps8an~% zmXuQmf#1M*gO~sT3HRGo zRtNl)4~*zYgIz~+A@AzTbB!hFl0q_?AB>oxu1F7ED^4q5PW_NwrQpXQmoHaGht-ES zYg?dXmSaU9h5kMEt0{OUkm{5H9IxnmC%~gDRUfHq+@vwQX7u7iA2I>#q8$y6gk=X- zC@V}m@G=CIjgXKwjDsfLDBX|xI>7TZ1>sObG=<8}%as{FtJk^-g}scF?DF9JY-=#} zzc}F%^0>Kx;SziblB8L8?)i5y?Qv1DrLiPacVQCrNRzZnAuR^{h|;~lNgvC4|A!vHId$_>Hne6&HhD2Mj*z$fB4Eo z)mdcNgJ-2}`8iQUoL`<3Q-F7lfX>23r8@fC$5Kl^dcnJ{=edxWt*b%RG6jIn_z&ri z5doK+-d#`hOR(4H_UHZp%9FDSpMps$kSH-q+HtDtqYG3G0WF~8GEVRXn%u3ua7#fA zW8p>iGgbhoYFwf?GlAauV<`58|7}HL#7cK?zx+j_9Y4G`{cmOQB|GOZ%38Q~6HVn6 zyRb+_VYN^2dEmDLKYbt#$;#l#fA)bk(mR+y-;9JfOCZvI1swBJqy8*T9z~@g zM&NS8cf~Rk!07+vFNBFPG9#yD%UNk_ol|fW&@gN_G-Gh&GVs$NJ4H7sO!oKtAb0b= zGp63k^xIxPNul_hPrQtXv>sg2$6~DmZ&V{Vd_xX6j6Kgt{5*&GgWQ`%wd4JQR!$P~ zP2tg<*V6jF^mlfc-fpNdg}x~SCAsGlX!3g-LKb3xHB~&|_%nSUMV}%g9Sto$`pmkl zx}i>DIR)N(dHf;=yv5l-{1MRG1TrfRgC{vj{O*U=-PV}Z;{;?5kMp4|oe^m#9U3y#FTNe#jy`>s#qEuw?f1f>s!Cuj8&vN&38= zQ*Z*}g+_U^)_Xj5)G@6=mJp>8P17Yzx?>>x?y@Cs@s01xsJ1=CR)6H`*E;!Z{+oK zn`~-YUY&p5mSi_i&bvC~Ld46g1-N7@PV#EF%}gptH7oPfR|KwDxwbN5Nx%h7dAI?l ztFa&6C=U9$sBvJUzIJny=Ew9=CnuuW*HuBu6phMvG$|2AjXcpS$h# zelvqQ=r<<9aJD%bixdH+aYtGK8qm_%P+T#QPiw>B6OJ=Z%;3@=Xfp!#xVtsuJLAKG z0_Ud|x9_^MKm>#4D)mu+K85n#zroyMw)yYNVyCa|-20m5kEV}%KIl*7!@alo)Boh|o;a7Wx0|4$gOF#`UwtHB279dn(W69jOI;iu z9%-3U5<4o$KeVeyTs%HcCGj}7oO7fEsW=o;6a-MRcAcT>%8(oU4w~@=v>0tR>f8dS zk;b;=nC=E6Wd$FJQJY+2^_Uk;Cy95C4>u))hRT+xF}Z>hk~D3zAXE-7dn-_3<7;AE zsRrSdkzUknI*wmil;j;q-O)tLfcDTTYbwu?NV!Zd$&7(h*mID)UinO2$lcQLdiFtk7KAjurbnexCN8v`;s3pYi|PRbRgI@QX~)gZzHH zUttJR0ooDv&=^z*T_#8b{<*YsMRwG z;e%#~0*w9dtAD(Oj!s}?p~-Y=W7Np$qB3&5Njc-a{cCo}_s~Udf8LKa{8xCE)v-v| zT0SY`Ik-7CuV+n|K%Aq7n|qvMLgAfgu%uiv^^59k=qCZCnX|psfRLejQGPU<^mADA zKZupqV$TD!3iY!fPge^k+i36hxia;qw*_%l@w)oGp21LP-jSCt4&-~j-=FHP8|Tk& zlTBmTI|`Yrjge%^d69f2SLgxT4XAe4k97$#LOjvp-+G>t_<&ra7zd&?h7F*JIzz=E zm92Al{{7GW^Yv7$*7oDC$Y|uVFl97fv0tP@-dIaguEOMa=pQDo1?pdx&kZ!CNG-*# zdb;zULH=KRe+G)O#Y}q`LWXfGT<_HO=m-bx|J@}k^fG|v97&*=fZOT7s1_P;=G$X0 z8N2n{GG@3_K|w$y?AvJl6%us8Jd(IeK=Gd@r~XI7s= z%-asGjrwL{Gj6_d7@7@e<8q6n@&}d>ZC>^reU!yM#79264B{4*G)9)J0433;q^bef@?v3uPel) z=@YB^4^5D9-FYfi#~zgd$h5+N9y&eXZDvEC2ONBAkL)-7tEcGbAhlR)ntp$Uc7|)abf>yn zHPsxK`aUyrc06k803@mP>db~gS&~z8A!czE$%gmAZ}^!>+^#gr`S$)5Z=+i@qddJc zfsKN?@%@Ix5RG3m79?(#I;}y9^lKr+co`KkNHQVxHfsm~l^)?7qaJCpF8qWDg!ZqozI}sy_)MA4GNY;S9!63sJ(vBegV1XvYntvLH}(@IA2V z@DJm<|9d@;txrKMZJ+|6Vp*u{L?IPt(2*{+5ftmQv~kuyZFY{v+X(Tbz0NbGusMw9 zZc@JP5Wm;XutVO#ZR6G&=Uq(w8p|_kpT=pq(-%d+SF~dlZb=`~ebYU*a+o&s=jMe+T`FXn$wv zOaD4?hT3wcmx;_xk^EvSt{?J6js5S%XRX+|(X>JnRRsWA_Xw{}l#H@M-!guO#7zuA zj{9Fc`+IYwl9P+6A*|+)sQY5R*Rdw+kf{fFVZpx>x~be)g2tG)3;}2iPEpOmg8V0q zQTcw)Y6`2XWe*`dzEAe#LU}-p_lX3N{#@m?Ni@Id1 zm)MAYs!(~^1ZevH0}RQVJ5@;93<_#_x&9IKLnKYXCB)$h{$bXa^37KE-R8fTtGuxc z;UxX%94@kYCUe358RM=*YUke11h_B7LTpP8j*I3aNR6Lv`drw4`Aa#S(Vm{jUh!O* zqEc=kl|ru zkfZ~wan2GY-6m|}&lapRYc2R60!7+oE(j1s)dw6A&(vcYLcs#Y566wAA{(r1d&)6lP<=VKU!EAD$}?#3SD_svIVf4hB3TjZqB*%>T~+fMm_4oUbzyT z)>{$<*Mx7Nt%-r{E)}bY@A;EJA1C$esK*Yn5<&+!?XN8$^sh@`7=vNCyPfmXq8K%F zVpFF;jmq)k=~5WcO($H~7yfDBX!%E^eOn{n?TWefmuNS<1lti;f(;q|Jo8Ed&xj13 zMUN$(wwwFh*7SUJMJ+ZD=Be$-5Bws*`@TsOqSPvGY}Piij3}nUk@7E( zdO9WjBjF>mzx>p@gPL)yzZ)unS|{-~tF8-yH4&au%LWQ%fXcmb!Jqv_PaN}rxyf`hN~sA^2JR!1ZmII78nEwP%CB$M0( zt;nRiq8oSLPDYh&*K=qUje3w`0qHHiD$$Zhy(g7ll4URr_H7=F-^G8^gkIx)&|*|G z-p&#%%g+|!g7^{)_CrSv^bGJ{Ua60fRJ&{TY;O1hh@@e*W8g-a^t1wa-h=b1|BJ4O!0^=dS|3^hwBw*~bF#lETsZ_F)1`%gi5rje8PH+l~mhw1Y4H&h?6UK~9l&8S6_wt-M~EW-$INn_ls zd=;sw5K{G2G&-y6L0Z-xz3^HTzc5WrYkQuvXy;64IU7P4N-ADqA-8{*b7!}6r-Wp- zD)YJ&?iAG*fflOLjSWTl&jhsvF(S);U+*t*0{dl@q(l^>yt$18@;~=z4n`78EVS6) z+->dmBnQ0O7;L-OpP!fn-nL?&*W8w_LfU{Vh;)9n@$i)te%!ta<$zbDZ-+N=_-)&b zYV(zo8cL9EVx4^TF2w^!`q?}p1m8UubUi8gKisrsPwk6(jCmburW=LANtP^HQm@9} zEx|lmBF3ys1~=3g$>|7j=4R(Uv`woeFU`5oWR4MFcIOM;Q@;kWje^ z!-h%In{fvwQuhQMDFwe)nEa69Z~!wP%0Lo6X^n+-l=8w)pJ_+OlY9AN>(+UR8@V)( zwCEhT(jsMq6g*pN91eCyAHYWy_dD0)I=!k)ETiL5m@$pMv#y6A2{eqxB5^bmx`Z&z zLQx{LCuq}<~K@p?BNuZ1XNCP`n5L9i(<_t!v>Az5Bot0@?iV+KRT>jozg|qre4_9 z70sA*=i|XlS5t&hZ&MhYBpYa)u71i(T&bBbHp|ETMcV?4&F!*nx0|BP!RgE%nzEI@#TwK2c&<9OS zp7aUepLT+h`yryr7_8WSwOJc@Rbg~|T^8u?JOBX!&r^vw5M_>oszPllal+Y15DtcM zE<3H>ESU(CH`dNpx%k zC&#GYO*_7L2)!Sz8I^CKA#5Rd1)wHeWGwh^rM)rL2%bKeQEfE0bAGBR`FeyvZO}mv zi0m1RCTC37Aa_CsOcs8e#J!YAN+ZFEsK-ep6H#EoC;Htc8wM=lGi>#4c)4TNt8unj z$kkiL`Cwhd!^T?AZ{?0(@rQk{MjMsi(Gq`um6kFp2@lDV6nLFT#6RO+qgg0_^arO0 zHc=}9er{%~s6!SDU1@h4W6zdq$^Lt4{JS+wx@O?n zB51p(45~E;0``-J_}a6yg}5-pbPk^E-o+koU^OWoLlY16x5jbd_AbfY4kH9K{Wz4k|&3!E^sqz zuv>1g zQ*;H^mqoM*dx3Wrxi<|$z6yO{L@Fv@9ZrZ0ooA+y*;v#sAxO-VXe0uL3ZiL?dYn zvXU@sw=7jAJh!{}B-n(a&arQhp@lh$cKJ~Mxi?15=oiHN9m!dn=f|z%?;W6b=t@`< z#pUC}lOGflYQ}6%+Yys~jOp5BF{e5HnIqbo5XSPeOlGt#I#??bq3|)mRiR$~BiXyE zB+$*R%{7CV&nT>l6q*u@C4YzYTZ083;5u;46nOSzW#B5C@dh!`^x*NXqVo$-AikWO zNwhY_CM+AL5Ur4zrsd95YISAm4+@Q!7xn#o!1B^@MHBz~@@09oh`2`1B(h7(Ax#!5 zr9*x<9qI@aaWdVLp^t^gqI!3Z*U|kXx+rGC`(JMBX0Qb+kjG7CcJ}mp*T()6OvRrm zpIHv-gAkIM#|&4JnQEn5-r!#@asaP~A^O%M+JJTxQ7`Q#`a9n-+K$gVd(mUNrC?m_so;AW@ZXv9BbmL(v`cXdjwM|~{V6w2aCzJFi8+~> z0CCDxRY=p0ALXzKhAg*}<#@{n9`S?B1$Rz#2SLCvw2+`cVU^%pe2P}j((gOCz`H(! z%KjNR&Y+8^N2~+doRDGzvVAN?g^l^+Zb`6oyVutOtE!6}%(>O32zm160V>9n%c|z_ z$rlR(USFCadlYjSvWw8cxf&ob_Ic(YJEL<7^qPenmM{bZX_>s{`u^)ayABwXc%78G zeBOdvF(^~r3vPp$T@1n+@SV4!idgu5$sW-6Z%lFhrHs!waFdtSt4a!ys(A7C&ZMM#4f`L2Uqs=b9^t}6pC@p@Y0qu9_qmInl6!`I*pta27;tk6euM3c zU#b4zl*hToKTVAXNqBygSgWQwzOIVNjC5kWDrH-c+CO@;j)!|ohxj}4;7T^;JqVRv z%>0O4f|2Mnf@tAkASMBY8Wm$s7YRT}yxjhDJL)>Mi=U8hh-gbd`7ca5j!sVIz4l;T z82Q_bBig^)hp{AQ9aqH#PMevFOt-P7&?AIIcLun3eFZ&hO-cL}B2U@QpNnz5IQsm_ z_YjYDTu*yjEW9eyIE{(3G)(njyz>9cNVNblU4VV$S_VndW6ZJ$KFM9x2<#s;|B=5#pCy7stg39=MwmX{zF zrYMuod&Od)1;tnt<)~^p#ZaO)`}#sNl!9SHrlx+~Yy>^B17{&*?TXHo@b+_n`l3!W zYIzhVOvY@9p3q?u9k;QLK~jlgO~DmWLV$)s38Ea2|FcZ1LDVC5M6?=}M31L*vQ&5S zsw7z&ry1ry0A`q8M|F4?eN?h`QWf#<2}U~e7W;gUCp>OZ7ZFSiDuu;*iLXjKns^L& zX&Kys{%-=FnQ(qL_R~pEn10?**0|UkK0y6?LZKHO;j^i;n*PV7NUWf)65SqSU@GH9=YkbUR(SKfoW&8*GTaFHVc6rHf=? zQV5VG3&Iv0svJV#i%8m# z0(c2}^#;yh2;kCn8(BC+G9pCa8J6bPLjz2T^`t*GsffBj&6DzUkciZ0ypGYrc-Z$o zKNn{uqvQ_OL{o~^;?1E`fv*pLadp-20w%V^-diBAj;vGjhCp$({n&#Sb#Ir?H)0eB% zn}HQkx_RQCZlQGd!oK{EpP8{jgzM4lGsStn!ef5F!uCU@k{lTi5@39yQN+)d?N+18 z{65`MDTzbV4;WoM6v`8apSm9A`40>ae+ITKS)eaK`IviJnu}x0xkdF&gSC;1@;j5mdk?7h2IL+%4f=M5C zAGrbce-4r=8|S6G7d;HALsZXJmCJIm`J;O7$H_=HWI~+|9bZvf8I4ca9N$jEHy_R~ zn1462Mz{#cilAKbsy%m~Zyeb!l;d~@&JX8KQOyfOp3W93YO;^-3&prxsD*?U)1FQiPTsZezra5_<%c{_@@b1 ztU#?URN#5l!;EX+Xf&0{{8GS5S5wT!^LpgKlT4>2dNM4v{d(yjgC4Huw~2gxpc58d zAV?X3DsQ?nSE4*=>S&n{S(PH~-HCZcm1J9P#!ft$W242V7#Tu2zPqN#*~!r3erX9` zE~s8ZcAu@@>uoJFuY;pHFeZ&nd@bT!eA~+9d$MG}#JAmFtPQNFP;vE$4WRdf>^n;ad`2zbLQ3o_O__c?v}o zkaTXJ?8SRplS{M$6S~v9mu4@dlN*KOW3<^#qLL0lTH(86xH-Bqfm4m&z&!^qUOmDR zf<6FF{VOG@7mr>sCnx(eLn15V8$IezC(PMwb=gAffXoB1_dv)%DSqOyr)Lyzj)2?_ zX^fb>Zro1VBz*76Lgv$pTTzozD??Kbm1uP2wv=^7d-OUu{~J3lsO;n1CVBreG{sa&8fzX1 z1J2X8JpXTqA7wPE&widbOaVF4n&K5OgAhpZ3H7};5Waj`Mp1TG&MI9;vJ@sunPd6y zSMe0DE=9_ap<}pJBGIWW-Y&P3vdZ2dM{e>x703WxQR@lNul_ey%lF+D?}e8eV4Wu; zVi-ZAguP>c^TPA(Hw#?NkqPB*TJ*)S**FNHE62a~3ZYbedVL&OO8>3@HCbX?V7t7X zG^I8?%nlq;nH1~Uo^q=2JS1vXNDz zhd5L8?G{~H!7k-n7QUdi0(riZU$*ZR_RzvN22!zE3bGDhxbLKI-M6_9ix3*WH7yVZ zb_2pQt`!j7*TMsF^}i@31BD-IRUgwSxr5WJC& zou;Qgg-&ffY6gK5Ar(o=Lu)wah(ZW4yV97&1CVfdVhFskTUMbNMNAr=U=c0UC(5m# z7cnDk`*k_QF7TYnwG_1w7#LcWcO`exaaNfUsIgw8@}U6U)%O3Be+nlQSAUng3PHD@ Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/08-colors-basic-light/resources/textures/container.jpg b/08-colors-basic-light/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys zy=$e?5?NMvgtf4$5v)JkAN1@PxaL%LlnT7H-|AYMo%mpM)Q)68A_X{^8$_39JBck> z>{};}sE*Ev8lafSk{>wTeEVG3Uq~g_8S_b38 zvl%)q`70GVU2PjNbXQm%t4aDk%~|`W93BI6JzW}$+g#35Mq$q`zOV6lYf>0oG$-$$ zx_u~OOOtMfwucPa+af>urgUk)`mUnM zX7MEU%@||KGS8m@HZllzCas2VY*%#_70^w{w$%FVd=)siSwZuxogN!iHR*n&TNFL* zZK0VNSY7dXW}Uqw?BG0t)@(^2@7{_~M&JatXZ`K0cO@Cdqq#11-?t@w*AB+2YsR1S z7Cu@s-llnWxeZwpYePG@y2Cij!`V8l_>^*BAAfy}Q7O|ZFgB7L`)N8ktO%wv-L=b+ za6Hhm*Fv_+9nL@D942ASOk@Vl@KJmOgmE%7$_>!LvL*zTp36b|l`EhwW0K(Q4Qg(w zN|9*8sXOfUu+O-Avx5KVl7Y);ZwFKk$9y8?2^lXHxa5Q!O8kpLdC_Hwr0U(Y%GG3L z(@SQQ^BShzAL24w2BzP1y{%`T-z=bA#ZKrRJO&7J%wCM%gwe|mFjp9lDc@RJS~>7^sY0?bcWWx5;^=t4s!l)8>b!+@Coy50NhLw){%*PV)>9|_s)9*r@~P2hXXr%yTa=(7TVc!@ zS)cK`QPE#tT;{x#D&3N_cc)E&mW&O2{d3&>zO?u9EQCpogy93i$!VFzwyG0mu3gt521i&i}ds;HE;H2zTZZbYO%so_VfbrwyIJ?YLXSoK#I5z5^)#iv=D`#7)l zMMXOmZKnuh1aX`)ocEX;4mz?nM=Z8uZ65K8iOsMvsXP?R^gkY)uYUJKb7_dt$?*YA zja|NHud|f-M5m&SQ~xo3abIrp2)cvk$3U8)pC|*e*=G*Ns)=Atk@oP6Mvhamd-E|+#!NAO z^LDUI(C4*^%tIXnoq%iOd;lwW$JLT-?boH%;?)agBTE}u^ba%+v4=21pD61ezVbrm zp@T0#cqv8?v!~ZdtH4>V-{`+2fgP_NXMGH`q;{rkc^^FWE-G@$pC4@*(C#K3+nw*< zlN&P5&&zP$Kk!mr+#Fb0kwY_@1W51Lg+EHk+Sg^z9IEPft#HNL6FW4zJ~G^-K&`DTOHR?&3sli{w4epCp^AI@hezw>pMv8i)H;{Yn3u zECc7_Sck`q6iec(6jKKq$G{TxhGas&c~Iemii+V7j}Jo)LN0pslhr(z{VkWoger!B z60^G$f~rW-HeBe=tKlRbQPPH`1pQm9jUO26j^0$?uP*4P$oTB4L^@W#?iSJTaV?%S zo5zQ%kaFnrM`?AzF#I*YeitvPj-@f8Olx7uCq%J512I!+@9LFn-o4qWIbu8-GZ-82 zD=6A7`|+B)D0Fyzo221e;o5r>@sIYy_=va`S`lpRDteQB`SO|1Cfh9uS99+t73Fy> zS>bta46zsuA5=J9DCpAa8P$k|IY)|A`Ay59k+-1^Fov-E5Qem!^LxV2}-sz)go}n zijKR!c$d_-4c$wut^S+~s7aC~e@)JL(=vVELe)>>ftg(&KVzD~&Gy568q4tBkUoJh z*j?nV9dlA|p7-kEtV%-Gpg^MI)A#^#IbQHi84I&L9b%D;nc0gsM>+g!$M z48uG3lb7-OHC`92(shP2KRpKCU#wV4OY1?cp*_orcBv|x#-Wqf!wrnLi`I9foT-LQ zMTc&Fl^RZQbM)A77g<3^F5^NN)$=X*_p)BNA^p_AAJoC0s8hfn%8&;u2hZn8f_KYE zna89#OWMmqN0}Smht)}GJk+8}{eXAS-&3>nylNk*QmtJqyP6GKN^5@K@diDh5^v7h za;D+NO^fcV*E1iD7uQHS-lD$Xj()24_te&aS(n_ZXL?{RVSmZo(wu!>(ZLedGNC;#lkX6`_N`{*-~ml{ zO@DWu{UhdL;`<%E&kl{>jpZ9O$A2mGpU?vbh|cXpq5bEQunkPZ=h{nx4YtNjESe9q zLOzd#&9}Snxl8TD)C^g9yS_zbTH-u+ke1TM4FP}iTlFy1CtxCH zR|FER?S^)C!LENa90~|D zrVNJsvrf3HmZc+HU)dOAp8B(~p9OSWot$j+;Al5zZL8a$9V|c$+UB_ePT)TqfCH3|-BUMf}tf02*?FCb%ai(txft6O*-*o7EMkNsNRiN!1nk zZ#V^qf9F$hwbnO4qE%RR9Zt-3f0tKqux9#CcwLkO`UJ1z>2O8&H#b1&4u_$gT$L=* zmY5!#2&rSMgZe!yFffK0ykf)#uEA}7R`V~->VtOW|EXC$n8Q!Jjw|en38sdVL=JOx zayGJqgM$msP|&#axB5si1YJ-j1t&Dx$#&q5d9{A zvi(70)(Y0@PZ@sMmP3DEPu3B~2@SO4|DELS{#tz`Cm787yl}#K{-1fQjgvgV$r(IB zPG%`+g^x*uzZMBNVNWCgt&zc`2JqR~fD{Mt3|h;B3Gxe*^g8+vM(_j=+Kd0eh@4p%W5B{&M0zkSsV0JW2Ib16zH>5S{Usfs%jj>%n*^n{Q`_CK#k^eFW0fj$v^`{uR zf2QI|9v9_+fWc9Q4%aY?3G$D2a876-ni4$lPBQ9Be`^cR*44?)`5!1;C(tk-@n@e@ z*2C1UeS!n)AhC2qJE_8va92w-##I0S^u3&aZ}WsdnK2j)McvVs3B3H@?mw2BtHVET z7AMO8Cq@%x`_CH+uB8K7-_rIUT%<6#gM&Wkp`eaZ)7QNAd&|QAjs6ESft{19x4Z+w z_P3_Ues*5%HyZ3Yp7l=ydk`dWhr6Qx1H0jG^gr2&tZWrQgM8P&DVO4B{R*mo2w)LF z%L$3mH38bm8N3yv;D6tv2pz!9?BB4&RwtX^zu}3%A-4Nh_LDVr5z`QOuLY;G-1-Up z^BzfY0)rM|CtTDgIn0EHoa8b5z-7$7fLSVuKM%+x0O1Bf&;#cjX!myNadYZ%bLw$( z>Tv_^5vLwErye(_9yg~RH>Vyqrye(_9yg~RH>Vyq|LRn8>Tz@8^mFQQbLw$(>Tz@G zadYZ%bLw$(>Tz@GadYZ%bLw$(>Tz@GadYZ%bLw$(>Tz@GadYZ%bLw$(>Tz@GadYZ% zbLw$(>Tz@GadYZ%bLw$(>Tz@Gar1xKB=++{Nsqm+j?N6(Ayp!npU>nC%#AUzYha*wEmY7)l zyf7z6K2J+$J^@~SK0sQ|6O8C>4@Wau!9lBT8J4d#^(;&XYZ(?J5lwzgXGORjLe1M1 zuIH_#5A(K%Nm#SU$udcMN_sjvJHpYHOrDMoNR*_f49iL7k|2yh^RY0Uu%PW_SWY5Y zG8t>?fHAyX;Y=dDLOd{j0RbjaQCPj*!D#8N7iV6xMO8hFqLJH!FLh^!2A_Ag9O5zHN zV*H9Kzssm2QD{prI6I~cSPL%#VJ)ekASxj!CLyROprWiSC?FsqB(9_=EHA;&FDxM< zBqaK~>`zYtONak=?OMYmZJb;kEkTtd94&3(e7Bw9wk%A4`Yw55^seb-4VPgNI%!H$ z(G?E5Ab`F_APV!D2_AlN9)3}M@M9C;Cntm@xcCJn`T2jcg5?l4UjN4W`->F+UA0!M<6 z79QXW#@_){L2OH;al;0fx!}TNpJ{0uX#e#qlK92(i#K*+WF}81&+0YFcSo^Si$OFSDCl zk+0G-$}3u02L|Wnw|5Y?J-xgi1wW2@9i5q#U0GHA{zKd6q2Yzar60R{6aW~pA5z z4eEY!F^pYUZ@NT;LkSGsZ@@|Tp!D2%+KZPii;9U$NUEr+sb4k3NDH^IwL{!SySaOS z;yert0wsF!GV&EDRZ41FdIl(3S$PF0-P`7OEv=x4y?y-ygP@!IHWm8(`G44r6SZjku_SEP)LkhLKpvvxI=L9deB*mrz;+!?Vp#BJ}x+O zDmk{K;SVpuL}~DsQ=}~VpI#;m+x_Vd#P>zl zw4l#r{I1%(4$CB_qa@R~ZxxY^%d>Z;?5^lBfX2JQdk_)Wt*&zG(%4=>5Wb?uqdJ{J z1T6Quef-`tB(G=dEVcV%xAVzYGSv6FgBn$e*b0@Ib?&}TrAVadI#3mjVYv*(C!|#B zrP}I8WQmpwm#(+E?h~-Qos_QvgI#h|rGH$HhClBMCDDCjq2-{EN^Ve|R1w%Cb!c8# z>dH?&S?xelI;cLlQbWI5Bids5;!&5yeVNj-Fjrvv+k?-Q;(Dz@*6DJzuMC#txKjD3 zJr5$Jt%YCoU3`BvW@nTS)hZPf*r>1EYrUH4>ygEMHTx1B$>W^a?mVq?@6o-kk;KYh zTVoLKzZte?QoqjHB6yC^uYacK1$JflIwMWIv zm^{kXwKO1~I>YmbDR^8xq^||e>fAHz`7I+j>ajIKXGAY+Z~l>0Kkh^ODG~U6mh&&v zXl}uh?>oVN#C0VKoYNcD6^N!=r`J2v!Vkvw$;{e4Q+4yQhqVo`U6|ZV5M#%~-F#G|%<4baUMaH;G*e36ZMVo^Ced#XY0v`Ak3vb zka*k5qvOoQ@2fb?t{={E`FfCLgynEMhrEcRS$(K3!jdwuW;hyd0CRg;D0MEjxAo%Z zW3B-)ELcOFWb@I4^H*P0(b=3}@m}>B zgc60efrV?^1xG2%q%ZM$^W0gwUm{t@cGze~V|>I-XZW~v`@|otid?Ewo_ayJ@kw5? zhD98HVa)eyN{G;_Og;!l{_JE(X-a#XPJ2{2+5EeNOs*wX zYtzS`y~fd2*)@I76yn~FOS<&WwyQ_waeQM_8g$(<;~nT3JoD+ZHOa$%_4`kyHq}}C z-nq8FQ32?PMzKC}3?Ui_Z8t8l*u`xz_NQCC?N8vdIp<=oDc$gb{6SPmSYej6*(LkM zN>AsxPaLM-beh7==MVrwybDV#H+J?6o8UVwSdMEuTi{t{I=6;Gz~%awdt2(p*X+12 z&K$Vo-r0=%dTuCzYY9BqTdvJOD52Ulh3N)QDj%1LmDNhd`fsW2pDy4z$+iVsENSG5 zL+i8zg8D68KDtL{TV8^PXa;MOk#0{176+=dU9BA(m)_5cylF^%%_4^*KPOVzP~Pae z&{cI8N!6(;WQmBU<#8(INW%ph+S1WGitL*!v&U#jUGz`$VIg&wpWUk(nAJd2% zDE)AWb2t5iiwWoB)R%EI6mhStvSin)!!4(pV&C#&PpJ&hST_i>&E3?I@FuilP7Wez z&W3x=P)B(aMh6Ot6G99829Bh;oH%qthsAsZ9Y|ihzELqpESj8s^`Kt;LEAMed@jUv z$OqB2$DK|YG!@U?x~(?6q%P}iS>1uBWHlRxKDNdEcBe+KW<(=&P+EWBhF;6_syi=N zsb~013!fI--O7*PW?p`6>7D($ws4R}hl01+hhRF~I*lFy&F^Npbe-?|tpZsGziaF7 zMI|+)J_pE`<;n@Q^xn3*J+=^)CPJgvOB5JSFDZb-W)`JLRcIEcUbyGkmMbra=rbpS zOZdkfXeC8T%ck}WbSR`R%tkY*SFzn&7oFiMXXZz2j@`Y)8HKuW+3JjLXW5TuaUYe9 zBKKiea7TdjFL5H09y1|DnXQD~RTS#OygBoN8@gV6By5*;UyjFVyv7akx}wsf85G8N zR^U-~{-zHOexI*qPG(YQw5ha8vUAJrq^pJ(hv$(!BzaD?-yY6RP9qe(g6X*8nfu8i zEZKRei?nDqzx7e8V$-=-Rx)8V=gl(3B8)cDus43_8m8okZ<*>#FS01?!%}Q7SlW-? z9u&p;EMBmC6&D)8C2AVV5gqE+%BEA#bo;y-QM6k&Y9)X|~4o`=Exl6m##pp!TVw~6!S7zx>R4A%9CYEKMXYhKuX~`v5 z;Xa|au}Kcc^EqO-z@((_1Q9Z6xru?g%Aw`cwz-dK`^#UM$^~>p2~Rf*B{$E1f%&sIbU{?%osuXn{s-C3OZBgN`x{jsQgWISg?u88zGzL;HKxWUQYwA(ne`PAJK zF2!5#491;r`^DQl%?O*(pJ8YhDbnDe3)Q2xv710+pZn5tDdlj}p4<=H8S$zt^IW3a ze)H4Y$qRcagQFbq=vQ>Rsv6v`%7!y`47rM)kjA~dywG7hj;VF$v}-pK>ol+JhdLrc z4!ZIzM4tHg^#{-5JWOnol?#!KdGh?K_l5-_yo0~=N257%qR6X{(sS{shps-#U)%V2N@KOF<7r;WTsQ`L>iBZ%jrt!W+HU!< z^(eCI@7=e|n=PxA(2F!Bm0c=)Q@yZr^n%0Muf#j0?#*mPXcWrp^b0T3+kB}) zu#4H>#iK(G1>7+52TaBId`FbvE(&6m58hV+nGkY1!XYnl~?o>U{Q^pN9qx$~%N$AKqI=Y>i z%BX2GrZ5Syd96=ugS9P5K&7qlTUm>y`W`y?jsEN{o-t2gjcsawa~aWPbX9xH*3op^o^NranfgTZmAOTplDkUmM+P&nQk-1 z@q9co96T@XXxJDqnnjbsugp zgyw#1c9TS$Vce&DRe?|dH%yR7Wb`G@)P+)^z2#SD7Q(b8naz40zvdrx5;G|Lc>eiZ zHWz!O_RF|7X#)+GByDEXNza{WhVEMB>A`|q)JNZpt8PDN95JwpPdrqc*7f?R^ZDsx zVwSX}TQszbZV$}wh>J@2mcrz%$KI$=f72dh)TMM%X=2Weka7sU9qrl>6LZ(HZ(sXj zj=km6!7{mf!5O1+c}K~MOW~K-m+lC1$jw@1JytdBGJg1^c?#;p z<~n)rfTYk^y;jx7Mo#*nv{kj0{rGI68y9-~;yJj@o`*v7iQWPNX%`rl-VTft;S|=2 z;v-@Mj{*6-RLfDnZ}*~y_q__*Otd)1j8GfF!wLS2x^r7b%h8oG1}cPQK0%9YnR#i> z`uBaZ0tPDHYI&Lr5kqzi6xKQ^zy-%8m&Iqu$94u~-NCCqV;CTDFpTSX1)HvyZUK*% zCr^DpEA2_L?1ZmN&KA|ubUBg!muTEH3p3c%LiGZH9M31e8y)^k!g=8@M?h>7DIg#D2y=sHomq{lWOoisx{2kyh_oPT*I4zX|_EE&utO18HaUZ`{CKOBff`HlsjqfHL?BpU$*?2)bB8%&ScEgiaSlNBlQFz2$%W!D>L ztn_`lF1#!7I~aCcQ5#vyPUw6Jo6sWPd%E?3>9Lofy%qMQNQp1m$u`$lv2_<6YqQFW zsHS%eV`#!9ozv5{1eS@XulLi35Jx?}o3mjcOvWCJr@8rNfeowGpASxcW-Z6V|QEjSyTfw%-f`ea~ky&8z{{T%uvcEVE z3r{Wym|r+oRLI_bABRs(O3}e@c1_YyDwA>88;&AN7D_Ngduc<>T_kvMpvw^TGwb>Y z5^1u%O%*jkY1NHp9cE*oCe)))1-0VzS>^l*9)^;YULWBe+Du{otNm=pS>;sWb5^t{ zQkDnBA&5rh#m(b~-z1FzzaCYEkr*F!RWDu7+wZ3Z^)c%^4ydTaDe_fBa#dZc=7SoQ z#E$nDYbAmD2QT?MNX1_2se14FKKf$BeL#B9tlu>G8mdKgUoKf|7Iq4xon(?0V!r}; zp=o8aS3cURt}j2M&$78g>WkMs6*@&vm+NV1p!cCgdOfNyb8qxcTkh2# z;Z;R6w9(YiIbFizLrB{4sIsvK1s`YYPWPAH9Q!FgJzaXzUFg_-Q#y;Y87KwUwxMXn z`Ei%o9B1A7)e7$c#B=PgFRQOvB?%Z0aG_xUk?Z}K)hKJV7A-(8WipD_ObS01w~%}B&EWmW`~ z${ALvu=zyNn}7nP39uKr? z#0Ti(CggwtwYvkr%GwHbL-;|XhE$}We@M~x^s$iXD@}E0QSlRxQ{mL+qOTOIr6?&X zTWhp?Q$e+yfIztm+g<{9n(sgXI86`tMTAK!6GoD=rquXeRLhT(>1Q~eXsf2Co|;$| zQ7TGrF_qYd3W@eljlMi6YV57EsM51-rr_wpO@IHo!=afuUr=q{AxG@w29{Z3(&1?i%quo=te#_@YLdkfaz5)M5S zME$DJaTFCg<}5Y}df2FFJgGj*M~9~2b}M6cw{gP-1e!?Vlzl2~A5d}HS>7sqI*FbV zH#=eQXh^-j*KTOCnX5MHiP=he9;as~N{3h|V~&?e6k(8o?;gWm*XO&0)4I&fWNxSC zI(cGxd^Uy&XVxJG85*l=w_CBl8T_(UP6x_q;!dY$x|xzWuMa-@<-@gtT?C_4$Q0#m}XVckm2 zm&GJn3^&Mtn5vbiVm@KjPTk%H=G@Ym0Ag!>;XEmAmUA|KtD3f-4yMDfxG5qvwF^^5 zp$(9*8+T~hSo}{JAtJ3L3_E-mJ>)>Qd!oW2w1}SzN6X1>bGnd z2A=QN6BN~m=gy+w6zfqwUcsI!ow7$ICKF6t7a_pD?KxFhA!ltqo7WOB0zB!J`u_l) z>6Iy$E77!sr92eWcw90`H<)zVh)H5M6Ki;LU&H62ysVFw#lz3E7 zPQj8`u-I+y8{XTkuAHax#)7dm<>oFCfTUJp>K9R~CyoiLP}NqXbfi&JK?))v8&sWa zp@)aJi!RQO#)`AQfaexwQ#2e&lvSKA5n?TmT=0-YFd@T zU8ln1mDS!hlmgrBYbht$#+7P+@D#aT8mnn;`Fo&u5Cuc(=UA(HuL34j%7 zcTnM>TmyTHi98Qu#Y|bCaWs*4iz8(kze0KPvZk*-RpL;>Ci&bV6q1q!h`BITx4r?_ zPyr)={rI*TQU?kY?t8zqRMEEeos=nY4xHr)Cv~c(t;Zq7@Xh;_!dnEyppkArb+r4q zOSq1dy0O*sqfPK{Q)xYQN_bsF5Xls@F?o$8q+OJ4WZnS>SNQT(QbCER;9zj6rnelX zo$8tdLjxCfl9`)*jn3;Z(@s>dk}2feED8`XoW)&H9UOxwP}h9M*%{3XhmlF#Tl}Vn ziN7wC&NSe=TB$`ga9T+uo}(n;(NhH8$kbCad1?z-{*v9n`nb`xl)*HiIf9U&Kod(E zPOsur6rwt8xrIX!u?pBzxC*4Ugvs}DFv}8n(xqoBQgNsdb^90dZ4L{EvtGhMgfghU zg5@4?fIN$O{ zsllDQ(M})dTQXvh#ay{l4wjml#+^+SK}&tB72VrT+;jP20g0_AG;v%iEd6NAG+t^x z7lzR@qizC@pgzLEY=kzJE!&M8nH@EM=T3A}O-5=;vo1f1i3u?^8|uPg-p#+^=S17#9=B`s@x#p5E?=oVlcq70xU|l6WDk8G3+6F*24g)tj3Ws4sENi(mu-YezC# zg>c043>5SwD=<7dSa&L@H1$K??QIwv4p>`t(`vp@;ZQ4cjtN&!6(Py=OXYi!EVcY5|5MuBWT1BH)5SEIfO0@n<}0s>}o* z4P(eTR)eS&)wPt^3=M%%PJf!u<<$XGDI@(F7Lb%IOMt|Eh1b1-X8B>X#N$ocYFe;O z8oVO~z`Adlu)IU5nb>6o$Ejt)V2ZtxmX#?K`6iN$EY0Ms4Yh&N_7}N4Ce*hP;SvQe z2@Na6Xz%5}RUVph_f8Ey71b;w`LJ;cWkf4;HpqFhl~^s zkLIDO9$q7d)sSm&yhJV5Xx!M5bM83%Lh5zod2*+0E+_bT+e7Ak&XHlB_ExTgH;3BjyB! z_B+DR$sik*$gPEyj=t!=mmF}T#wMFm^q|3{1!gHxJyX)u)V)Md-areRS$&t&ijt8N zN#vSl%DJv=52*PoGEz?Brvt^PF$y-8!)StVe=(==ZYfnzo1th*LhXOFPka3~zZJGTAX8IH{1&>W`Q}qKCv!zm$8!;Dc@hFa9vbm3 z5NgQ#g$i`Il{~nuOl|JPV3JCpeVSbzXGxZ@q+G_bOeY0n(WvPD%% zJb_}8qA9B5hQJj&;uf--0q9T!h@$m<`t2^S{a_=4i(HZ=i_DHi&L06B*MYAj-=j-$$SS%mEL&SXYDM{w5G z_TuC@AR0;C=_aQwG<4L|6D(mtV9TYx#gm!_obKsO49^u6Lq!uR7L~ln?Q7hNe%^SR z@*5o#5;9AO!H!7I)=AzNSf8>1u@>#cEjb35S|*L3qpBDKW*HTB6|bN&HOi^m1m#Ab z9tJn9V5E6ak9B8R^P~0ZYP4eAFv;{NR!Oi-PLU*%H6W01yhNRTzT66KfGN0e^pBkh zH=QXhr>?3;DBw}9S;Mgpvm?faL{z$<5h(^;U<(Z0(5XpdR*uEa7ooAXoiBim1 zNAVr)^qzUOkyKhp29}v`3kgGoGRCB&5x8OA`v=|Im2pIxb*8}^DWfz|Ghuj>SjGiB z+UfR;M4NKRP!UZnxTvC;VxdIY?=S@J)ce-4{JFBDI9Id?tP6uElMULwT2xI8RRzbo zS8!8t?AMi2%vQr-8dT6xVszNtwGbzt1tTmKJBYGwTMa+pYgaI-YmfMvz3qQvKQ1?Q@i#54o8;(nfa*NBQ` zhCv3K;lL=c`siR0I!hsGmOE_)cPY2S?Q=!xr;}^}+e&(BS@2p&=ZckI&oaE}GAk(} zX*_MMxaO>D$ZUZ$l*6k(o8dIeJv4E~$S$$Q05(6CymDaSNyr3JfpF?MsKPC8k`Y7( zC0zlv$*}|wIbaPpq$pEeWg^ExRYW97p_VxpagT9Q5c_*`TCuHnU|~)b0xDcCNL2;X zVGX$4S}}gd+sa9&gapzn6R1k;5!qu`m4Y}IyA!(FZZ`Ju^rISKQ5Bsql&6XpSv=~8 zQYT`!3vt+e9Px6h+8|TrN$BP!)QP4=QH15}IINhaEhr1+sVL19MXn5oQ?7t&d;v*& znWd4A+J4%_Zz>Wf)za7C9V@}`tVm&t7F^4U)cIQnNYDH5sb6`51_U2??sq+orsl(d z^*Z(Im>fE2bkhvkvxt=%BArmH#`?FLr_OoGQCnRs$wfhhs*?pBF3A{05IvPh1fJyF zop?2}N?AZkMFDQ*#|o9kfvm}ws4)CCI=Hat?<~R>DuGR}W7~^bc23$%wm?qGw_m~^ zAkkMZQSs-)BCCrJ#h{{U+K@?w>M;07M8Cx@Z{f)6v^$a#oM>6POoCN4|I;kLizX4a zi=mD3;akha%eoL${{W&>jV<2Xgu6Ce2L(-=*oi4MPn6w1IL;$oTRkzTg=pBsO~{O; zGRJ=2%koWC&YBFa*cvJMuMKP|s;OW=vd8AYWEUpVn-C7Z3&SKTii>lFI`ns_S(m5S z%?34>>7PKR5sF^3)gL&l$y6{EcMc# zR-HVg!!hhFX>kge1ua!PjDn_?sS8A|l6Kx1E{~vLp|QUsl8cP7&9a|g(uUx%nYAMY z`hK`odgdO2<_?YKN}Mkir8RW*ZzX13$K#LmRg}!*Y1dVdTF!^D;OfgYMalw!pk3Zx z<0~muCv!eT5n$LgL{}#eU>OarY=y0-vu_l({F6*~BqwDit1{z3g}4y~b&ff=5!n03 zxwkBrfi&x_1mJ6g2{ta<=a90~P|#6Rtlh!@%n%cQ5^c{daaUzCiL7|e2SE9oF4JL> zw1?#lZAwgnHIAe!??t;d+KNR5InxlRs?Aa~kv%kP zV6jXHZ+PzUw-zM>O(X?G(ASfqs$7waLMt1}o}!r;FzlZ*9*d{n#LH0D2o&(0HI}Om z4Oo1nDDo+aXqanZ?*ng-hbyYCgwi`6!A&J*7|;@qwUn|eK9?SPc-sCPbq+|TE)fd# zrG_ojs+#Hu>!_zF&7nj-@pd4u@j7v^^iqP^0+X~@B~3md^3{_us>BG1sv73RJV>a>4x;>Drs?wYKy$PZj)^w7fTZV08u}88#e?RaW>dg90Mm-zA=Gek~P{n zsv``#s8ywruYX|!n=XwqDWtYipqlEclCuY67(yh0^pUN1_w?<4Q7%m=P$GtGnMnAR zZEaNKLls34NH;dp$IOc4A8#4BP}5ekC%nd(Gi0)0_|6mZF(9OA1S-nmnYS_4HzB=hrV1&jAf>#qpLM4Dk)J}(TiDIYg*tDsJJ%q;&r$J z;+||BI8aN4U=Q67ZPvv#-u_L%3 zp4<;^!|5(AIw(b-Ta%{_HC*`+lp^|vL!9yI2YcL?htSxb_hlA%|l~4hu@WfI# z5Wt$Qjz*14az{I}Ni%HUOp+^M3sVOilHbEZQYAIp;D|a`D8;f7t z#LIpcPPEI<6GIhLfoF}7f!Ig}z5waQ0)ZWLr$`2;)nRQVRVW-k~T*PT*fh%xotX5@t+siSmahFvj_!7PE zrx9jXfwu=;UoU4;Xu9Jx71Lu&D@^jo5=!wR=mnJ*y@!Y<+%auJBDAJqRJwXblP_Uu zzzHES>DQ`k}U)Yrr(pC zBg(f_0`5T@EpGn+nd61Xtu~H}Qlau|FRYH!$<-{uKqO)j*vQ@8;}b3I3r z`g?%IHFGr?r&kK)vdr%3-|9~v!6N|Aq`lyC+<8r z{HUYjSdKfLaY?a^$2u6&^cYS(@={%D5n^QpUe30hHAK|zaA(9`C89YVzM zQB%tmLmj(Jko)QZ?`0SI_&-t!Q1hY%ECE&hni7TcD`8bNmzCYts-HFsN`beUCSPVWhCHvije|Y%vjVu;kTZOC|zjj?OsM1 zZv(B5N_wA{qQqksj&)n8ael_##|Abxsdo@~P(k};BLhHgH$dkF%(8h_`8qb8ZGASW zJTYP45Ty4gkx7gb3yLZ_w^drW?@o-&Y*;Ni5~ky@EP1CLGgk?eVX~5V%OwsiMOhko zzv#YNnOfzxD=TUTek^Tzg(D*x6>BoM%{i)@6UC#Ju_}tCdQySr0Wpp(s&=nn7V0n>I{2fn!{Gv@uN6U12H+RD_>U9D zb)Gb#DV!;alc(5DXX-ysvfeL=91jM@F-$uQ#&N`qN@-y(W|BaJuHqFtTyf6%VFZn| z(~YF83FA*v;dL}rlEW-pO*1Ug`ATdEir@lmdv@aqcudlQ$pVo0ZUFUJk1ti#MoJfw zNqozK!X$D9zdk-zK%|HSu7nD@77Hn-aLlg36@AquwAxRzjH%%m(!?b|b&3#j{!E6i z70Z(~D2bq_#OjZewCb2#@885CVC z6Q>lg?h#Eq(4}5X!G2;$sk=o_NM@CMSp=}$538QJSkp|hk`+%m<169Sn2sGJR99M8 zS=FPAkSqYbm;NQhExe!%QIe7l+Ed_}P9zzMPc533Y&7|DNpWjb!*EB^IbBBz^a-FS z;EHj$*&qWCqNvzp*2CWHb=OmVFH6{AwwYT%(YEyINqP>XU>J0D4VWvjDmij=6iVA_ zYN?<*k;;*@Mkn(aoeJD=w>4PstAN{EvTqd%XY1|}lDch}FnWAl>iUacjnRCyK0h5^ z$RYsR69hu-?(SgZ=udARdoC++9RO4JXzs}4G+D5$B5JG)FwapVRs57k52bepa9yh4 zd)D#(JT`gF3K2-yMhA^HLz5n&mn4Kh&tKw?#r`En`#q4W?_O{n}RkT)WSNc5-MaamyulP z!pE__#~0fxQKWYy>54L5iLm*pa9m;Lh2)Z}7Q?Hi7O+sQQy@Ba)NmiaE5SZgFWjcc z3!~HOHlgt>Qid3!A!yAdGoY{x>xay&*6=z4KAs16EfK1EK6H7!3xJv=IeRb7OOSB% zRSdt&>8FT2i5I7d`}|4JazI;yRRP;*#L#^{QkF_;m8Xof?Il18hW8PxI}e3|@j!cK zG>o+=FepI5a)n>@TMMXqW~iq$bml$d-C$|d_u~&PRab4e6cJ|}1>nk*p=BjvM}ec8 zRz?E;I-O4pZC%G2NpRE%rz%{w^jHQTh(%O{*6*dPqgclDh=JXiblrObJVz?!$BHS| zkTio!91|)ebkJ6$UT}G-@XVMzd8q-m&hu}O%1wk|HHD9` zcH-iwZYd6lGJ0rNtvE$pBzSZ&7MWD1oU!P~%)55>U%$hMaTK@-srg4BRN;8#B-P2~ z)P=6u93xPRhsgV{<9qmVx8Lx^Xfp~1qhfhht{R#*d4q{$0!Wrz%Wfz;qrql4zB_1_%=v09?QK@_)Bp!O1NNupjEG_Zn?iO(Js@sjUysgXj zPc+jQXjg!%k}DC|bnrty{`LiUE_#s>frYS-ixxLY7T^(DB~H{0|=_*3_Y@gwwiU2{g)~#CLa&*@uaBgt!aTkeqGEJIfpN`H9Vy$DgOXNBE+`bt6*54+rw=- zR4D;ElS&HgKjpBZ79H+HOaz1N1@i7bu>57!omBHj!Z4uvx{DOU=&@Mik&F#VQ47T5 zaNH4%fIki>3mU4gq{Pv{8G0$Pq9u#Zo|=$hamq;A3~JI!HSyZ%!jh<`(3~-#-wx>o zUVO%CsH!TOk1Jtsd`lNq1({X+;S@oL1}5i?)WURVc3_Q z2zPzWzqfES)7fng8d0al7#fdFOw|~L8X*rP3oA_OKp_09fKN3dyaqyXf*nH2<~|{Mg7h+i_P?yNyc*C=#^!Tc>e&>Vz}Nz8~*^x-M&0f(J*PJ6AG;O z4iOx=CRmo8VV>0uHAR@8cB)GgyTlJ?DyIgxss_9iAar*(=KP6OPl#olLP|>dH}fiK z%9Bk~O(8d@l|OkIez0stpm7doXw&G@bwl*@O`YEB9R8Yvx0$T-GMgQyrTDNSfi z1g%4egdt==#e91(Hrx*eHg`#K6q*ZMHd06;fo!iqPMIQFuPlk&$u&W}z!Ac`ZS@}x zELoLdT0{o=;(%x|db-M)!qfSXM70WJa6Zc|iTHQZ~}D;#D6U!Go*NW=v9o zoX|Xlh94Flr63YV1afWy_ZGM(+rl&~9}O6p6e;wVGOti`Z&xu~ctZteQARtN@hZBg zl0vnWaaUplA#iq?B$I9aJWG0#0(9`J+mR-C(FE&+G?cw>%rx=Fk<%?q1~?!d>I8BK zU%P@^QdG$4qQ_GTrG+BXoU=y|Rb>^F#&nPOht3iS0QdpTHcq%S)7nZxg$bA;np0M( z9@TPIoqW6BOZfhLqsBH>m>o4M7od(je=O9;N%}Z(Ds#&CQ8jZu}F#>CMdBiA=%abMQbBg0^8K13!D2s zJXVzwk_{zr0HA5=mWG~5B!+pnMsDg=R22tZE#JQwa8j^hg>IVR6UmKIC_-SD494Cg zC_eC9B6cKv2W}y{BncIEp-Sqa!PPZdC?uyyt!a`(l-zB-lGpZMUKrbvG{wqHP>qqJ ziZ+{cYv)OaFk6HF02f5W>G0;?G|=#nDR)JPVRdwra`_1~j2Cc1JNu)D7BlyW|& zXlC0Px3b)GzVQgF>F}C*=^hc8>$46xnQochraW?t;WEHVig^|Vk9i}qGdhMoHUqae zeBv~Trfl0$S&9<#Po~=37ZA%8xW*;@WUZ@@5lQH&q>@R|l0xV~mvH|8C|t6SXUB+b za|{UKOI);6PTC2h%J9dR@meEHV5>4sLhEyV=+-QE0b_q>7pcr?8)?9iL9S8C^)z_a z9UT7kDx}R%uxO;Py}|J(n|0|;ZL}GRIM|+9!(r(TMX8FQNl`So#T|VWhrFhxZHQ@Xm{&u4=s49 zWMrY5wgjb?Yu#7mD=fcIO?ZQI*E+nubZNXT5u$bzMW+BtbjgrV{{WPRIt)GIVn*a= zp@K_W*>l07)OFB7AVdnmhhaY>hBKY5EW)tEZKMNKtb`wpq~_M{I8y^*18oR6O(i^e z8w11RZ_>d-O)v{_{{SM$TV6C>J>_{wgwcD?loH30O+@hOvLp<}edZ30t&a^YmNilv zk>Hx*uq)-Na0isB3NokwZn67cA0BDJ3N?1NP@#aFwwOjag1&^du&>s4J; z+e(Cp#8``szy!X&%iQsCUKE_C#X`jf4M`PM6zq!8LM`R$tlng0Tkg=`>Emiv6!wF{ zg&dI;4kL}V46G%a4s2ystP;%29Tbt+ldbMNI9%`{C$5}t#-J%6a8<3xu=7=+l1Vo_ z;ldkPfx6gU;PQd!rD{hCP(? zz_+s8YVFb#IwH2iTWRvS9p$7+ovO_s2{Y7y(l}Fa4$uYv0A~{GlS%?~iLPBf!*aBJ zHLa5t#f~3UUzjo4x`e2XSt6*0BMfmu%NRN}$nYz;^G~?G^QtS%AtkeoSFH8ZocB>l zM2xFO^WpC-O`{Fo@gGfx1PP52X&TNnKW6MYsN{?Ski^1MM*jda=8LfgXKQQp>%`5k z#7%qnXcfpfZB8AR>zyDGO%yYEmKV|4lV1+N+l$utDi~5^wo;lH^7dU!z_pb#&gEcO zk^pv%BaSuISKDHEg5mham0KVY6s*L$X+|h9nx8uB9VJaj^EJDgeYO|&@i@B#ic-5_ z(}f9G7Ei6D&N#zEbAVy$8oH*ULZCE}?;#ADUuyg3_eQ6~iS90dMAneeQ2?cOrjl9iOil_nhYp?Kf>S2&&Mx;&dv?%sZL1t>&XP7`NWPv5>Wq0r zu4)ZTHL;NFea94%Sn2HW+(o;)iMGkJGb+ZqV_pJjUxEpI(M7$ z&TPrGPX%rh3O!9FSu#>pQ+X*PQ_UUh(Yet0gQ(PTr?Td*8Yx(%cG-ihEGac^xkoZ| zV+yKo5E)b*w zn4o#EI+`56H8`Z(FPMPIw^B?+Nhj$y;Z=a1z|&RvO-bYTlWlf;=7bc znogBP6pp^qyt&b_w1meblg|vGcVP`v?YSRM4l?p|QY)>rtIITOu*7BrMy*d%a6ZhE zPK$H!7dmn90ag@{%2Tq2+%B#xD!**7G|f_kQ_9N4bxzVOJTWJ{4#Xx=u& zXMlwU07TyC?g{%o-rR3xDF6{e-$`Q?8G<@GRx_2s@#>b>-9Wfpp}vB5eH<&hSpXAH z+JUMC7Y?dmsZ;Zj3r-+d>k*WH$I+=DP$!10s8bJ$=YY{&@kVBKr=g~&qEQ*z#MCn% z;U6})4w2_fp}8_@W)+0PmT?GDqEgsCGv!s%d;8i7mUlv}Zo!E9zP>c#$@8TE0YlDJ zp{k*hy`cit6f7cgyVTyIHyWQEHR2n!NcE+Roj$Y_OHo^gF`?MY9YnP@5l49A5x()b z>GrNI#SO#`s%>r&B9%QMtiZ=}K{@@jDznEzMph0Zp*738R71 zoWWO9)0!+}FlFkz$DAlC>%-=o7D%wVY9E(@0xFQ8I=V9*PTTx=MRJI9!eB)lHtZ)F zE!gfKTD3T$)zd5$1d%Df|u7ok%~B*BIsRRsQ3)u!IU;OyK5 z?d%rj^TFpQ}lFVLLNh|~cb8FS3U={&XfiTT~PIvWFX_3*uK#lTNVqZd&v zPYNb@q!G(sNcBJD=G`x!IRF^L?(g}Y9Uzb>nN&S`N5|=~kL%S!!YZMz#b8)z2`Zri zR>+KY_t04UcnsepPJ=?d)pPHo57um4W4U_-SgE|3Xz?f_B$aI?!s~DLK+px#>EU+h zqq|#}@cGf+cstOLD46By+2O)zqn%Yjprb6qS1KrATMv$$9xWuAkI=aCsrU{s)s!+) z$rsDCa+eUwMc6P5TX$<|_j1Z_VXBpJrREn}l3=(*ZiK9KH1R#JwSv*D?eOC&Of1&Q z@S^*j^90q@wb)RQU8W{FMr&`4gGX>}VQcW#+yRXvxm=8Dd@;=yUrC-V$gu5=Za>`s zwXOA@Y0tX6+OVnlcB$!b>S@b`D)7Q2BwUX$czb+#RRJ}=^B9Wi9BbujaY~OkEOk-K zO)LY$bWAQb`1`iy6pFf6P1z1An#zn;rK&bkQqwbtTX8KTrIocho1J*$qA5EmAyg|+ z*2y2slEtEr-e!@(C05^dhQo|3VM=7sq0)0xHg}|@Xd127mk^d3SOHz5_G!jadE^nsY)}2NzO5xF|a&pmZ2$T zT6{($Pd&()WS)geTEGGY$m6W1RMjq3fTRUhVM!?J6)F-Kl?00T!abmUT(!sD=~cH+ zgx4xWkYcX#63}lBApSTQsne>1O(C}XskZA-_7CMk;IiA_wpvpn8W z(D*QjacCYfJrtQMgqi?y{{T7l}- z39gq2!{b#B(8nw?OCTi%*%?Leb8mLW+)4~9ZCxnVl zK{9Armkxt7Q_F{$T8@KVYzNB%9r4@$dx)d7#OqGOa)kH5(MfYjdV0 zR)V3hexKp2Pw1Gen53&_5yx?Im)BqTlXwml1^4F-lp*egsFE=>U%H=-VlqHlJ+yEv z)X-32H1_i8;`xZzV&AzpyD`+APX&2xvQRLfhGTHGnL8>v)2*)VduTe7+~-yT_!RCa3D{{RXs$y<$OuBf{s$5%m&(b9^EY#G_`_`x2{En~oD z^f&u-d44o~lQ?^&dHk#Y*L3_+u=r-gx-(53Nkx)OR-U2@TqBxfD&qd%Fpr>e7u~l2 zTF+O^RMT{Vq^7m{&2Na)=bUTHeV@t#M+!L6l_TC-&)-5V!KxGrXpQL#BZUT;zOJJZ zqME*?OpMhPetk;~074ZlZq~K9WY&?7tM08N=iPBNU)662Ol20~T`e%-#X5e>x?2OkI@23!@f3(M@l>`9LGznmpQzcCF zlhZ%QL%U@_2F&}f^;l`cC4gYkKxuu7VDe*_B{fAnJ7j{611z@%S;PYNKMgK;mA8CG zY0#NW(5>meJ!USJ!D|E+Sa$3)7^SFC)Od{x8%s}9A7+i$PiQtEf&t-fZEA?JNYF`Hgw&rluLiG@AD9uenipNHJh?kaG(PYn zfHog`#qRA}4#UjQvDAQ1zIgf+=E4q@ofQc_20cyeu!<;lu%Ysat6Rv-IXX9~aLj4#iW*h(kSf z9LsPLrk#cmK1DLY_mG`6q6DRCI;Dd}TXV;1;!zUKxq8CZ{j96}x-J0Cx+4*Du71%hi^D-(QI37fFDO0WcaD) z8<9x9pS3LYIiJck4OvpJHR3Q;)?rZ9wFVxtRpN1p z3`5A0s6t$zwby*3MIJmabxn=5`2=H4zvxj?Q&fPmO;WXWF;f;}5}Tn_Z3Te7zkfXH z=C08KnkTEEnd{6@pC(e$p{TGbZWn0V;1pYx@m0`)258gt&k&-g^z+m@dA66t0ig2a zH(iFTPj$HP(_fDYuC;z;By`b=2kebk?mnvyS;OkxQ13EPd7o;;N=XN|a4o@0V8{lE zl%YcZ0HwtZmvQ>2VOfuxLrSuNq(y~rLP+s9wYU!6)nbYjZn)GHLq1_+QA1Xw1d5*( zh2pt8366rjHtX!L*N8WGiBRJoIy}swbcQ8#e6fEGTnry9? z6vVMjSB6o_vV-qg=u{Bhzdk1*1w}mqF`z4|`9_1vinfxqsaa{a3VT?#*JfruH$AV# z_Ku!3is7(CnvFNeL4rWZhyqM8houJl8A(z*4Rqs+1e&M;H6sP0f?P6brnGWzfuagY zT_;rBPhf6&qF~k538a2z+l3mMm3x&E2-!u!ETwIyjlLXxpcNF;iYcc4kLFnBe0L74 zf74VY;Wj0L#;omO?IYvM-n3v5RJJ(5qX$Qa%3>1+h)ZNEBPk3OhNo*1I~(x6DPf(0 zgg%^RN-Uq$JQA}QmR6)N;xtbT3`<^030M@l9xKGRZIz&bPOx+;O)V+$iVy25)>79j zFiXC2(iLLfVzh)<{11uZKH$bQr}F?BgVb6&4Cw+ITJr?BO)W+x2g?$rT6(%P1lW)U z(Qr9-ijj?J)%S-A3Mz8#RaPH^L0dY!atRutlS08;Z@i1!ijBycWl4?{t;=L7Y`;l$@c<$%xXLT0EI^rzAy%^$beEQMULXwl@&c46w*mchtyMf)p09-lqOUQ zr-)xKx5tgN-m22m7*mc&l^Y{w8gVg;p(-D&xViiik$V^V)_AsZ!tZ)68Qh;CRyqyhv9AUbrG~pj#!!Rf%PA zL~SZa)dV{0p{$qL^zmicI_bM?MM`WoJS!k>Py@DuQTdQaN}o9$C%6}ms#PRgLI^kFl{duGK+pr#OhnCv)=|KAs)Hq4D(VM_)7g7) z%E>UUx<_^;G{4Gto@LIlM=zfAd4C9ohC2L257HA$MI1>CA+$2M9y%!ZkHszen`lX= z>`>#X2^1mb99n}V)#6yzEs4#HWvQs%mkXh#Ri<$aQ3-@w9I+*(QcImp$vRkYI*nIp zfrdEHl}!s3YgRn^&~=L!C+-+hcns-^DnxSKqM)Aia zj~YfmAgCtCzP$5&HEbf0RoI;|#AykbLgK0g1y8-S$OnnHhu6n|t#^P@wu=&{3_{ZR z?NvX^3bWif@X(uf@#0cx;AnH{%So8JkCXEJ6;Q&sq?I^8R87Peq?27PSf1ZboI!Od zZAO<{I!eYnXx#O$(w0=A>6F;E9XVXXG8##tl_Mz4ZKU5#x4p?a@HJLjDSNi5 z(oY(7{2pnZrvvL{6G9A_eq^GjtMc1)MrEN*;dK4dEOk6ny={Kcv(;3|UM05&U4Q@3 zef(3&IG;u3Sp))}Olq=eTFRjzqo*KWzMHhxBj|63u2ST9k3P*1D;P%z80HDRv%A6z$Pf+6&RrzAS52&qns-Cj4Sekg>^sveA zuBa?^?d|2ATqHSmGmDJBgHnt-yZr(>h+2`LpLXV&M$vZPvExwQv*N2mgh3co+_uxxMD1CC*CY+z zN$9Fn?y$ewPma8C)uLi*ttC?=P{$JCa^$=|nmj(TlNL%ZB4ZUTK_nYq>$2YN+uz&5 z^(+O<(SUEmg$G%C5u~E4s>7;bt&7iTDa5TqQ)1#Va!E^HTb?@P6Cl$po&->X(T<@_ z(cCWp#j?}X$C+c2nvWX8>uIX|nUF*YT7)VA1o(|bt_VCVyt7TfDOSo|XLP0&;oDZf zMGr}RTlBuO)*A!E6Bs8eLj{fA;vS7u7aq{?`P45mtH=!Gm!T2@4p%OST0ztzD5*DLPzH_?qD zv}K||UIftp0E+qr>5e}gUT4L#)-e@pMk}#1EU}VC;MQj`5)H~*yAI10lCBL5lh;y91x!2DsHOo}gt)mqync=+dDH~rcGsbLh7_~S zl^M<~B0353Rb&+v<|@@_pqC(LPqZ{WxSgjFz|x13urL%6RN*yAi91HL5;W^TVy0ykgJMv#nmVJr)EJ>4F;DQxaq!}Mq6#1$G@+t( z)Qn}Z3|fw{Xz-fWd1MAC{z{}5P#7x^Q&Iz)9x{hQcGIB*<3Yv&O^ZGukB{V-rWzS( zDC89MRR-Zz_chrExAWr1A4o{XlQxs6;ZsvLrcjnoJ1=6BSE(qzZ52lFl2};Tbg;4I z6v$d)YT@k!NTE)jI#Jg}1uZ=_R1#Ow)7DDgD^skI&%CMkbR%!)#GTMc^`${&UR2kZ za~2^9se&qMlNeDY%{@nbn%e8$>)V!TDVn3IG}qEv&y>P3j7JcquBD$Bshbd3jU4L6 zFDVdP+}BmLz8rGtLO_~ngc1pjv@PLT=M$iZ3dAtFTw;?Dctg0y=N1kykR+eh4W-7W9BLA*0jKeZiV!mXY_3d)U4}e0(M2Q7 z?M!JZ2KyD*Pq=%5rTD}E;HTih08wkqnDulxB2b(o5cwe_(maBadjQfC;GP%ZqiRW3 z+AVns3E4&m(S3DQMpMs{)-04%SS3vjl4zujndExM8-uQ+L9YT^+=)^mgj=TUg^CsP z9d#?@+UnUIoB4(@76(Q9vP`m2Vh4Eu_avKZ;mU6FU$iOcA38bDu7X=mHC@s527xIs ziY2Kt3R*ZY^6;xQia?RK*&YOV@O9mtwI3z$Y9txDrEv1pP*nWOJcUdVOkGso$Ly1> zxnRkWHBR%xLmfv^YvaIjzF$P1DQW2Gp{T8nl1-?K0>lA32B&Wm2E>y}wUPje>pN9R zieVKk9Za=zBuW^=9Iowq-oP)%n`uc0ZBgWyie{q0sVAeBpw>x4B{HI#H>RFeoRUs~ zMuy$^SNDDw<(qH_Gfk}}TLme)4bnW5n;QtC#VYZ9BR6Al;`NYJ(Z*Jo zMNL}th&M|S19GmK>wZ%9`C5z-9+kUWWT`leXx3uhn39&AY4E&95vmfm%bBYyB1MkF zLv?`MXgEafZt_h0#Tm6?(uO|+LH0S(L6&H1v8=~ch@rw^ddX_A+OIwK`Am*>{J!Dt zvF*w=o4B$CIIO9-F+|CFg^oj?vHTkeixIEODzue&E+aKHL6z2`k~vC0xofFn4TlAq zQQd-0G#+p$IAdiPY>(6ewHVbtJ%`lcl=T>NloYL5Pf!BLY9Wvnx^_Da&HOFGyR=9Y zsii@}oh$Rs1Te*po_S4B_s-gCh1Hk6ig??N1_3*1VQ`J2pE_Nb@GLT;AI7n{=7K78 zrm3W(mY#jnN{KJHwo6>^@za#NM8F&>tfw4n+1okCj%G?I@Tysk5h8rM;syyeM6x)L z5xGW*ZFzQ@2^(uqf=R-jnx_lFa*l1IOkCDEo@nUhris)@A7ddJ3xIBXJ8>{vs2X)1 z7RaOyF`cm-(N~zWE@s4Pv8=PPkJ(5rct+Vbqk7yz)ybNA5=&pu3V*@;i6?N5F6-;@5WWkZ_@EDMgcd zj@}&OM4voojDI*!m@x|cE}>?g84`;Qr=_Ub6i*ujM7rGA+T`~<7uc}NNC^gl7q^Rj zWl9@sf>L5IV$UslOBF`I+kB~68*wdmJAJAJxTVX4#s-nL+J-SfzBL|XdYBd(I)fcN zk-N&2(vUV(#(Qn>HH3)s;SGKq3dcaQcTZ=`3ty24inT8Bj^lVNE!- z6Xi{Kjt5@pP#%L(cKLKvy_5nsX{gZgV+sP9TJf4cmin;ny7I+8xz8FK2)d_8IdDDD6xU^)#w{@K=#t?2BW`-?ZU;~ zsU8JV-^!)IsWdiZ?D>^?gMmq1OrOi~npQNp_5oH@Pf1Xt-a-wxD_h-e#BowmkS34> zC@LvNv=neFd35g-Zn~C0Gy_n-e}^nqh{l{Cig%&I;Ko{#o~DjT!zxqls3k0`*@!pS z*~VQ_h&4pITR0k7)bzW{M4C)7DIOSsK}`zCS8%o7z+J85elipQs;S*%leU;kZ))TVc<+2yrh0HI@Tx_A+5ah)V> zttrDao{ui&sO5{v^Czf~?JGP;%CB*+zASrj(&tTkA4-0t!XWbGRi@iaTXfqZjZKNM zzR*7|Rb)m38rG>1PjO)J&3LHj7^>Y(NQfw4dlu6AjxeLP*|l9pLp-BD=W&h5lDfS;oLal6D518rQ|sw;=`NT9OqN>|n~<?vUTH@LAVJ70+1w+f?l<|R8S1y&ZaPT*0cI;bk@2w2bn2qx=cU^tZ)VK@r& z`H^z7;aOKFQC5shU~QP{n(XQGQO8dhwYTj7Nzf5~+;6!lR?20|l_@bWDM^WcRH3Db zKao-3iSI0bEjmb|$98~&eJ{fnS_$Dr&bXsM)?}u^s;R1sbn&%3sPh?O5yZ+u?$wkp z#>DWKI8wmdg&pOo3Q(Q2N;)*HNyW^||lC8;+=&Buo`i z&&rr|Gl+b;cnpqq0pzGRHof+*3s#}9QJYRcp^FZ}F#35?mZpXUlW1uXsp2JWd@j2D zcu8?{0++UuNTtpjhGgj_OfpKU6IDIRQy_vj14h4Vi*TH}c1F{`4LP~}{SLkk*- zDQVVaEb^2W8tw!TFX5*XIy8;6?|P+d6~>x}r?^_BLSu1O#~>>E;57t-ek*-1!ouRy z{72bK2r3w)duc(3;F&icq?pL~eR8JQgcMZq31S~?ZnAaIHulcda*j6V^h*M@Z z!RgD$)ijm$zGQMn>#(3#y|mO{*}}`FRy4w}^rHk`>Iwxo(3ek@dU*6vy$wQRxO{Oe z>sVO6tD`HCp|S8hGG&Iq+eOQ{aN!$k1o#d`^JDo;9+H^M3r9Ru@JGB2PP;BhAH#-7 zc_{$WPZ^ovQRT{cTB2B4DO2=!Z!KblmrrfQyg1v6Q;HC9@~tIdAlDbmnNf^#NruE; z8>nT18+*ie0DT-#pb}P6^C(Sm-sevJl%wXMsbz80P+#B$h zHNNnKB+-^$!3xx&O_+C0a4bFwYG`OAljSa@>Lyv(=mw?37S#9Uvf`y}HM`rBt7SP< zu9`g<&{NB$2HgMi&17NOuv$%8b@g zVib12EYoBNrX6!xkSQIF;rVt*3~x$sU3t~k$@7~1~$1pQntyDCV+ms&R_i=Jr1 z>2Mn2`BN>nAr!}bO+mFaFPpdoVds(=kAkS-V`^|K?lI*;CKy7~Bv4nM^A=+mH7#92 z(%^B@)T{;YxuKGxM^Z~hrXP0uE=}|UUK&_;uc&kmG>Yu9%6dtn%~^`#+21qK;0c*x zz}Fl90DE!CSot(mg^aAQ-o%gwo-B1ev_84K45P!aQC+Q(S(8TNCuY8rej*#H_zd8Q^STL+|Z!ZrFn64F5Gr>&dhU=h1?APhx zlS_HvK*E@M=?x%Ap=yhzc{>Ni>G6tqi&nsr(7Y1J(o?)osrO~xq^Yq7n`ZS^>%_>U zuYmh_2&H6+fzeY`JI75TklQ|D7*D%%YwcVA0Cx^mou^F{x0ez?HN;?eYpP34M+zE< z)Vg^Qk-5d#fwX`R@Zq};0+~E%8|^`XSfk5$cJ}`OLW6txgaJzx!`K0B$a@oU#{0=s z(}_vZT-O1?#Wh)M8kfsDNF=3$ak;hs0LkCKD|V#mCTZ3}wG1dO&MQre(NUt{G!WBP zJ4XvgMNY;i8Mqt{>m(oFs+Qpbr^^rD`r3)9s{h{N*ENdW~Q-P^#B zISg*f2ytFtI+}05AtJS=^%0L|?6cH*tUD}XvrypllvK4bQm|Q4IT;4+p~G6{{E@9K zn{mGooMZf9Ifcfr zyveEK)kmv5KB73{>#kv@Uotq$MI|+mGlakSBYSge%B>22xr(Z{0(HL^j!6+=TDXNF+P`FSiUGpv5uBunIa#`dBBX zjo_lEt5GMB61s0LLbCQE{0r{}Rc@61piqY-zk8&_<5vBdaNKIGV9dEjqFPK*;92Xc zA|71t5`iPEfovG7p7!nU4-vpKPNgOlvV@K@qvA~jSl)f>bd>ESH&yCBevEvY($_|d zBwhSNMYB@y7D{k<3yha)zq0q&Be* z0S2Gp#Y@QT2E+DMMn5X(5Ummrp%#qY}`yG;1blY{Ka0@XvHiJQN&m5lGKEY0+ z@!9*0DQNv@dhC$-v>u@|0fxdqBV`Z_z_zD#K7+>GXZdZc{eqlr_hM$BPpyB%IvP2` zb;B8|mXT6dr2hbYz^|LUf-Oo-z0=Pey3&5pUi{nXm^8!w-TuER+8C=k!H!eSFfvr5 z8ZqUvH@XF&_8alTlv)$^ie%opIM*q?fBNZ?nzkvr^Nz@oNNJ^q{SjH!qghU|!aclU zd%tFXfKrC@d!(7vaHQORzkP6Fv@%Ia){JVJL#Rb+M>|S`d$d=-yUM3_EI;F8pIXxM zo25pjlS({0*Qc$#UkrWScg4Jz%St1WC|N|Rb-kd`jqiR@&DOC@{>*dhP9rzC+o;n- zKZvKVOfIgb7&_C5;R^v&S&}?9Ms24+38%fRdE{=sUXeZ6=hnRDd2(q*` znehBJZ}y1B>&7G=WCjd6{_B(j{DuDjbB-L2%oxxsO1^bMW}IX7+xUY_%Jm&_#S#QU z=Av4BHo=%}0D}h`{!wR$(kiIBdu-FKC*mFJb1z}=&5L!ar!YxbBUVEs$wx@&v4ao; z$c$-q-LH=tIUTx;0TD`(dg?$28jnx-oqEiptBS4qi7-l!( zhVI)&%Aw4b6(b6J#eWg+T}w?&wB1Umf}b0wS%bq*KmtHVyeuKt?F|X$hDmG3ZCR_A z3E54t{vbZJeDMY))LE;|d0JXIDr2RLQ!|wt{mATXV0Gt?Noq#Tm0^DB4G1#&&h=S} zWtt|g#ihjm0Gd<9GreU@aWD>`voa(=5JrG-z1`lmaeg624QB75IBlZOkNTJEnHb2Z zs`rCc}QqnUFKXM@z{A)66p zsimpPwD^CRAc^IMQHgnhmK9O7DuMLdgxl9-hLVtqy_MUJldBpSzY{9TEYV4WQ`10; zM}p$?jfT|IhmFjK1;rs_a6w=_;1v6}@4}tcd&In{d((AKzN=j;?i&Ak|jU zWfIwTEJAJa$puu-8IbKV6qGOo?eOH2`6ic%G#7E=or1GT>mSwj8u7t~bz;7PO~NQj zc>qVbfGj^mc<1taayC9lNX;!FwJjR_o>C#9I^3 zT~qnx-`W;wUxxbq^`s=0ix=wdCy3f39CJ?{5|wo~2i$|%r_s$jyA~?g*yq-iF`e9} z_>D?W#3R;C6zf$VR&fMMHITBhQH7LSP(X*_+;Xk%#gq^bG3TbLtljhcRn#Ae&#lQM zo$#)%;y8M{FU-6&xO*!SHiFlK!rF1>w_?e&Ap@UUVOhPx@G3NMIu+|f)rV2?t_LP` z>fR-aSLP`(4<#0wk!jW{O6h6V<~TsTqrH#p;Bz~$wP@gx6nT>VVZaR0y{4<`zB4>{ zq3Z+9RN>eP^?|kqup!iFFYLDiO`|Vag4oBX{xp2+SBS$^H0PeD`hm$gUb=cdu{Av) zS!D7l#Vi5M!&v}83pu`>$>EbWHY!$~1D{$hTbDpdCTgfUnd|q~o(t40LkY`WbH=Ig z8W^cDEHX&NBuuhROswL@7VN}=FYVyBFWs9G%1WCP&s_(vb32r}QdDU+KN4?Wf}tJ{ zPgk0Ay9e zgBvf|_h9<(#udA^Cu?J$T6ktRDTrC7+%MNxt^9FoWNx=t(wa#HG=^9x9F{h1%*Gz~ zZYN&qWv6RN_x?1c8U5*)aEhD$+8(x}sA=1;_@v298P+&sq8c4^v|aCRY;MM01`Q5< zYs$|rN&e_!m05S!53YPy3R=JRh{mC%Nu{TY4~`r>fKiA#m@jkj=FUfAfv3A1`qN0f zeP>Zon&7^+{cs^gZo1<)sl0wuM~5z>w|Fhv$D002XZ- zv#xs-8FTvCnQIGW92BNn%eX}mQHW+5@->DV0ks=u`R5}~xNtJVCBSWQRbZ}x{EVLLrX&h2nl~k=TYpv{Tc|(%fD+M5P z>s9_?a!1}xB%9Vht$I3xB>iT@C>p3dvB6CS6)MaU>^s11+Q;hRly3fC7$8rV>rJ_u zU6c1ywlC`w){QPLUxcSsu?atth+4jQpu*DrYHkB)fO~&$G%`y#9ud#2Z}ZQdCX=*Y zv3*g28{mDG~(?dJE{+XwlzY$MX`DX{FqZ#J9 zqOh_+*rAe^IT$ZsP()Ytw-h6GZFmS2%bB~pY72fMp0p>1KR2lLkw!0MjVS{XMT-Uz zcwa%sKeM*ch^?I6-kM>g_0#Js4#X4Yx~X3!MSO`*NhHFJQX^u)pLAzS3w?ZO?!}S* z0ah9H%1_*BF`RvO`puFDNczKDMufCZ*nAWWjKlYrbRxu)spG8f)sjqv3TfQx;E%Y~ zzWxf`V$Z!)%D$knZlPn7W7xeeV!~;n#A`N*Sz8M89I#LayvF)=;B$N|+h8CdMJ~vm zTiS}Tum96XekAb8ANiem)wqwNkdEyvf~n~F)X|xbwzb;p#uFwZ z)C^jtFiJfj`$E?8lI%YINf~RB*R2OH(+^`vn*0v9(}oB@C>WLpP%qf=Kzs?NQqeS$ z{!2XV7UetScu=_nTlBzpKF&HG73VF@37D=`o@bQKS#^D;*9PR;*7$KUE^x-YrWG{v zmpXpUh2pSCT$<^rW2Zt$KK)E<+sD5stD+5EEXbh;HRZW*Tr!>MVrP~Zl~^k58?Rw| z+TdJq8eJsGr*pjaguA+!VS4J$UsbTI?)iVHiTwV*0g9#^7a63aj*=-U zrLT%hm52eqbj`RP*V95dBV~DmA+H7#K`g@AW-zJAvO`AXA{ypv-JE+h0MOmlT3UdrdSnsO=r?`Zt(?U_GARZA%1KkkJIx3|9)w z6%~=!NChmB7BeXYgRro*kA?ZB)<>0j#zEO$Ofs(&!g0A4DC5KyvYIE3NWca^kw95M z)anSZ<=nV}DTFm6u8^3nM#ZB^DngW_rxAUn?hm*|zQTC&ZiLsJwg6OI7cXM;bQpvw zADu-bOBA9oZ*W51JJ&XT0-%q7J%syLT)36;j z`J{qsqTN_fTZm-5LP;d2RFa-(CJZ4}ATqDL*o`hYskhU{nRT*74w!COTHFsV&^*kQ z5ztaH7Y6aXk%q7&cCq3I7viNz3W}E|NvNS1WR&uioXt-Za?X9hdDTHX@5-gjajPsq zp=bJ$jzNY{OEj+7U1kl2*5UhsE$>oBTG!NA>%>aC8lsgqY)GVpohig>-x{ZCbl+cv zRMo`$NETRTZQ6V}wOu4vjj<*w+rJB(7EG~4>JZaLMQ_h##=0)65;c0sVWB<2(}CUS zbe$S$UR(lJMJT@$3W+E(Tu)5TOey7s!$K}dY%aX19?}c3z5IAZyKRu_`XY`m5*FHL zXsTY#`A|)X);G#M9F+9NN?$yNvld+rmKrhk@=I;N1q2j;t+WBx;5Ab{8M$lOBxL{# z32kwIqlPWK0HkiTLBf={js;siC-R~Ul$73GOi1=A<}o75Z{c%s@#ggnqN?I?ikp`* ze3ZD>9W7QIwMkZ6%8kL=<)L7`hL$Gx=AU>Jky>Ss6w{6=)3=7D?}d30)GJ5k5PjAy z;eVryw{m#WwXz7N#OVzAmcB{~Shh4U%~(>_(PAt0_r193yhu#b2)D+W>bglLUyRYb zb|-0&IM+daN7bi2`QDnc?MhYGSa5!%b!#SN+&d%XtY(`Jz-XtetfGQS3V9_BB*vwK zNW*aj*qdMB#-GcWe3GFxX0s=lOeE9nU1{spYt+%jnegg&sM#EbmkFhTFThGc>LJP;qaJNKmi9|9WQ?#Yx!NX zVp1`yCpWq$6G@EU)4J-cQkte`O8iQ%V$@Va3PQVL9$JvG=rkW$@5448N&rtqAh`>1 zT8`RF;XN*_#A-2N@=F)W8fe?h+zrp4sMEc;>h4knCvAmIEh>6%T~C87LJuwCatN2;up_wTk#W~v7UC&`9>|roFPGt|Nc^Uj2!)h5 z2w9j13UxQ{eR#c#ouJZ3nVqz(tm(<8k~MhL#zJhmY}BY=0Pwfd#=kInYRR_(k+{}M ztDh3WVpzh*Jz7(VSOrBp8%^EyKHfUr#@edw`Y92d@^rA!&??41M5G9T8-ek-Tl;x- zZgJa8uGoQB1Na=!&q@JHH*+_~&q%rx5cO-(oAT=XGM{Y8kf=)H%APtqvsC_-JlAee30Zm+xQ^XOs z0%R&y`kgFC(akq<1kF0*WJNvWIXWyGHRP#cj0PBmI!Y=Z-DdJxZ>aGH!<$3pNL1Ap z)GjI0GG(e-{6`RqrmR_nlDb51?v~JBv9^NzWe$;rZB5MwbU8~4iyy!!(M%$ytka32 zUB}CKT$9-8?(ss_V!Yd9P&Bv3G95-Z>pzz&K(DxuFxiYC8|nbCJ@3Ya*@|=W*zKl% zsq~u&sf+sH}>s_G3UaS2|~yvxh~qI_K`6 z9471WNv$qdR4qQD<$?ksq=^^{yAO6fWrQ$|x)8$6k7)P_&3#&F>T zn2j7!!;0ZE7}lbWRtVa)z2yh&K7jV_2;c}U>nEXKZ>Xr}{7Y?*=5Q&!^DHFlLLB!-qZd$A{E zvMCyP5ydV!5lu9TSH~>~rc*s2Nujey$#x#^v)B)S;!^e#PbIQ3te8F>O;;o{$bwg4 z6bUKN{){BgI}{Jd%_DhzN~LA6RMj_sn@dvDFQ_^THDH6tcuF;_>K zafvC5E*(`3GOO+g(#JxR5(jUwCbs>Yt=sVcRU2k$r!?ibeoCs2I8skB9d1K-$g&IG z-$y9ZgHl~j+WelBBB@(n1e=wA8QtBEisYRCB{X9!}qNS5n zWAGZYz408I!Iblz%=A1KvQQ5sjM!SMQs$MK5tam(jKb zPVy$~N*^L=0$3%ML^k?B;%0LhT{!iS(L88q&)5zhMTBIkn56ltMa!5JvC_^L^geD9 zg~0e7pxeI?u=y)E@uiS7iZ5Ab8N+IG4O|d;dm_VXsn$YRZQD#`AX@$x(~FjqrjmyQ z)uDP2!y%6p>n%5$vDQ@7VC^k4fEdQfT*_~uV4*$Vf!BojqT~wmBTA%FfAJ>6K5M4A zMmb>fq^idg3aIh-R|cw@#@5ozejG2zBs{a#Mh~tMnyqa2fk6%xB*sWv&7?6YWjoY> zpnwP#xZu^NaiTS}D5Fh-Lk%V!Pvz~JNs>1of1!p0aCv;0!JN0TSAaF?I-HE;ac8`Fh~`Wn;~D*=CD z2TmuwQPe!C`&7zlHHy&+DqK}fJd-m?C&{~^07!HIpNAbn!lIf|X+_g4pN1TjgjKyM zX)zo}7fQM60TGA(U=bGJSbePr?cz(@h*VOWR#T!)3YfP>FuIIUsVX6QWs1oqO1k-q z#kaD@YXWU^@a}k(tK-8OT5Xd!(SpG;LS@XohSAYb$xnh(`I2DN79_GsF)~YY;9Tn7 zE%$L9#mtSk(uS>qX&pm^{{UFAO5=&te8lFU)2`v7q6I*z27}x2;zrgHvXqimWYD2q zl&OEs&H;!|xYouo1c{w})n?S4w@#IUJ#U-gAsyA+ldsTteA1)?NFD?lZmyw*ECz;$6@jUKYL1C%>ZexQv8kdc2|g#5oN9_58g0WM zqs(~|38kQmeAr|zwL&p+sT;I=jr<5abL?Gc_|X(L^@$?O*?S(TmK#W?=3c-LEmR1> z1dim6A-7mkpi-wWMFSafdQ4XfjSVDeKKdI%w)f(iswU8QkRIPp7RrHxNE4*tSUUBF z&+|EIC!EbwRfyBl`LZsp7?9rA*Y}4nYPp)*=^;3Aq&_{BV5xjF$_j;NhC?KR!rowA zG&+skSi`i9#B|V&iDa5*T5lkv?>5$dFVewHwe zBUjUi_M!W3k~NRg7stnonOHQOpo}RUoiG?+SzJ@tvb?evwaLA;KHHvo4r5kcJ8H;( z1&S(qd>hm>A-ts+_8jO1h)^)~8tK9v^fHurQk;_osw@B1NB$pO z#&jNS7OF?L+!j28w_RQ}4yv2;1~jP$q}3Sp(!BowUg;s+SWAae)2eud2*>!I4|3Fg z&U)xSn<^fuSxmri8i^J5O#;YUcW1wQd~P}ASDGFXSsS5 zN(#AQWl&hlShiVrd%)dI_>Iw|;ZL+R12j2j?5$r%9vzBc@`r@eL0M6Q7H=ucN~+Q$ zH`!oEZr0&*ZUcobRk;}Oq?UA{#4B^BPAYLnjv7fTpr`pY_mVxauqB(u#>D;HUeN&x zr0$@X1XddCypZPsOHBT1O;0UkQK&X}#Yjfb>tHyTyD6tpZYB*j;}rC;XFQD>0p*J0 z6D1UPVtkg`zVC+P---~w0;#BUqDbTU+q4E=DGd z6p7)on6dgkTdUa3spywqBBO;ArLKA@u4SYP)l0NymC`nX!5dc9^X-O-(%1H4CJ52x6R@ zd`DtDI4k_faUiCN(AJd@X&{xNLLq`;s_YR_hK+x1y{DE+aIYwuSkTwL9fi#!;p5GS zQ>#|lwJy^wg~zjvt8UuZ7@A{j(LF_de9DH>v_LBW0)UqQ3w?Z0hKA8i>M=sDL6%Hs zBfz?l2qf$?w%7a{E5He3yD1l`FEK<9R6juS5 z{awDkS-rDbckRNH(8W!M;5e*?sY_N#Qk3eYRct0BTldxYy-O-MQX0vJifm2{LIDs} zri`(W-sZx`x%hZ-!lIgUOo|e4V@mxtz(q|Yo^}sB@z7Kw>{bm|ETaB5)B|oIxLFH0 z(}+mZ*IY5I)jlzf;rNk--RbDg8!WFN1{N}wxE8s%BHUpO%{|^8H9s4kr^(A-FTB*f z9P3L_1+OQUh}05ItQ7m#=E(+W#>%H5>H$q(~;M)6flNMlqRskv7()YD&Dj0@S;I zltE8lWjfoi7y5V`&IA!XNZHH(UE%5Gi;&)v@tYRf?e zvgGVPerdxa!syxNnJQxUEUmOa_qM&SuPpMRCa9E|skxg7tz1^4<`BaoGck@!EtdNT zH|_R;9AUSJr-+h808fQAZex;)IF_PCN2rce1(r7Q-3uQL0V9Tbp}C~y0mi3gyow&W zK(Yet@vJUMHt+8nf5dg=9DXaw6H9DXJRdGJ)UZbK<7rD+_{&Of5oMM&i~>c$weR$C zJQWVAxgbz&i|5%S%Jo?7Ga}-6b)cS_;k>EYnG~B10q!rw0hnJ^RIZ+VIpdYMo)Mjm zY|B$wIH6fson2lk&DQ{1L$BS&a}+@lR$)ZpLS}cu;%o`&1ftBY-e%oh*%e7q;b5Zw z07nwC;RcpmHX^e0e+#RZEMpjLJIAnMq*E7S3Ee|Vbla_lxAt?_&jAOjsc6|CflA!n zl;ejDcqE!7YMD01kRvf07)N`t8WY5gU4n3<184}PCre(Eg95IloJy3?R@FTf1Ryjs zJe4ALL>>*M<|jZk_Hm1_R;)I~X^jX;28UUr!m@P)eM;)38@3ha{JsT~XxqxE#7Q?1 zBRC~uORt+LA63W!I#wq`dw7~w5-?J>bWoK;o2JcuFBq*&GA<=HCyEsm=&Kby5=R(< z1iqyZDX{wcl6YDh?%aZSQ{j4q#uQRAZfAut>biL)Fnsj0%@3SFZ#E|Yg(Ll4cw_l> z6wM|}o+zUmnsW@JAZ2_iiiMd`f+oagjfrN|+<~CJye|yO)I};wke@mv z@aB=1v!(-Iny67>T8EOMsTewo;npF>~FByd_9~_9wEr#Pn39eP$$q+3|UIHi6u2OjU2@)+@CO% zn34_2xW5)%DC(wc(cv?;j3=uQr!HoB6;?8KDhS1tr_Oe<*T;pKX(4o?xZd&@lTribww$=rXv)RYv8jU$LSp1 zp2btwQ-w2Q(ltV1rWpO?s(_L-va17OZ(!q=og6z|l>1K}rua>4ZuKsBhPYj!agxf1CgMQYwpB^e@%_f?0uuTTp z(+*hZqz@ou5i^4j+(-iV*V;L@6lpVtk5}N}u)%`*glMh3G5jz{%b*AOcs?IT3pcS^ zl8RB1Kyg+7)(pQ8G-}KA>?z7rlTl{6{KHT8Hd&rP*5;p~b6k$)};LGDj}?-CU9i zhD5j;kWH_`w(isj2A3&>gHLt%1`8auxSk5{ONSMOs$fRaSt6AR?r!!|bHwDD_i-4C z9r0SUtHJR3C2<^YK`I!Jy2G(Q-NYzPG+>nikwC{#aRMjE=AFFB1}Wt%M(o#ARyID{ zYknD9rb4L=%Hcp$YGc({rhlcVM`}b&GOm&;ghD{P$sr(Va6fMt&;X|ry;PRKHsGB~ z!Dy#7b$>I78u}-Y`Kz)>pX`HgvcTMNaU-ae`Wi9d?dHGDj3nbj%lf#FvTeAI&+a?#Z=M9E+k3Y_PjN}1M3c2I055E&>l{tjA(&o{H2Oy8ru9X6QlE1rGrpcsJcvn zm4O6yaomruhm5`y0UIeEoN*NKi(|}knx#6KrTKg`NB|)DjP)s@BEw5t>*KmH>ZXd} zL>dif>y}E{piuHRyD)hL{?hHY)o%P$697dtNC1ix@J!Q+;2kyUEO=wZ1Xz|LkjRY~ zX$wb%#7RSaG*B$ zkPF)C8(vaHIJS&ZgyWAzh2`ogkgZIV^`b!FsP`(RHy8GSuM;UUqZF##m=uEkf4%Vt z%-hIk2FJSw*>As!n{NoJ-4PK()iyH(xnC~DO9@)4XkvB3bTE}}^Z6G3uejy^zSK?6>Sl*JB2&+sW0>k9{k8h3mc!7l$k%1L(9)YQ;X>p#h zr8JSrh6;?oJWQdkMD+E$N^bb@lQl9^H1i1>O)I|>>_(z)k>vSdP$EoPr98GIqcdQ# zDzn>N*4=Nfjb+Lj&y_mTAPL)5N1ZBRT(=CZIckWYEhEWsYe*daSNixOWA38+kV0s+ zRLxf-V6{+xlzBYZwH8tveZ}X9a+#wcc~rEyKQ*E8+@tgG380Pu_uzB52uu^Rd|XirG>x% zl?Bbd8tO0Kn?q(zHMY9KB>w=7Mh?#Z03bJ2Nh9y_$`6*6bw96eX=s$0s$(>t#FRAHhT0in z)Z31-B^9%_ihd&ajJb#TYT|wXpg>>0MJ^#ca8^K<3n&c40uOz4;fUExnF^zi>AMNT z@N6%s%UNo%5y7LRkbAEYl1i3xp!n@eeFudX?h~dc#=)s3hJ48`OT?UpuA9uBng&XG zD4o?^nUR3nFX6;VD)gfT1e_@$mT~$lwTR{nK8BK6D59Dw#v~BHJ{L#0{U>e6@Z(7?TIV;0*6sBxOKrH*n4ud!MvMz7|C7zycCvnt7{o7pYq)0_z=i zHJ7HbMX*?w`WsxEld0m1GL#77YtJO9Q$xyTDvYzy z%py4#%UPwYf+EECEXYp1?ih|2sjY9-(jhcPS2a<+WHj$1EZhEOh``^bj%JnOJ5B!p zcpXQLxO#@-k-VWkRC6b6!CBILpng5ASj;s)GqO0{>0`J8%*@V6x3`9O z1QIDFyy;aLPQGLKR%64lYExk8bYw&&K#pL-JR8G`a?ydB zO?n6b^j0biRyy1-4}BDh%71&gZO)@lr+4San`p_Tj;@BBLlmg5!|3Moo*5^AK^*fn ziBNP!a8OH@>J1#s@}(?|G%leSKbFCUp38UT zT2Yv*BoJst&Un1IW)+L06<8v!Ng0@tU>R&Kz8?1r8BD7hGjSvV97Q?h$g8SyhCN?7 ziWHJWW(-c!rbU%X`w0WF@h6m43W{k^ku)k}HDXKy1DbW&95kqt7hnl?h>M$@E_C8_ zrWH#zwkQ+K%^PMsokcX|m-&~R!V&|bybcHi`1?<@hAgMRqebV$u{$Zl9H%%=W6Kor zGlieb!#5ilHqP-SiTK>{Cb`CpP|yRendosLCVuJ9&bUf%<^~#xRN07VXH~I27uS!J z9_dlGkrI@;lS0mX!|*CeGa6y({b0u{E9Jr{@o6_SA1IN-`b7rUy9f8UUu~`cJrrc) zDI*$x#&c#JPnWW061ZE_)6!MXQC~#lLRM3U)Bxyh?*q6sk7Lg^!PHMpHsXYiimooc zVpxSnXG~VEs!FLPilri+cHGxsLhJPo9@r-cq*v+05kekK^J?(S3bt8G(#ua&n!M5<0)Lzi%u1vr}@6WD&rWI zGlteR9Q5Xmr-e%oJph<_WFgk%Toc&q&0kpufCjgh-Imp=tV<{V091PSlKp zN|rc|IZD7Zl=87y?(l$gzuA#2HlJub1{Yqma3y;V!$Kz-Zs9u7f~db|OtV*(=Ed+z z{60!gl8Ol+EvmKUs33a?RTl(%cp_!cp)^bc6Ep%-VNUh4T5bCTdji~Q#kjQ!os`qW zkv$au0EE!RK2guhP~-)~W2Z+1*pr5#3%A;D-;}t)LMwKS>TOd*vZD=Zd}j>9n6&ay z)hsMiaooOmzvNF15WFy?%4~$uk%oEV!Ro0Xj`2v!UC??oSEsL^x>L z)9eDHWt#XZYq3gdf~gxUpQLec2tuRyTaD7Sj3ScVMXmXHa`98H&*bUOH&*$5e2{f)^ zjDJ(HpXOaYro-f0Nd_B*${sUic*P7sln(+*Tpy1R+qI?Bg<54e(HqQiM^9Cmq+lkJ zM~<2)HM;Gl3T=Pe!<3VSA<==Wdh|O4*d`~|3?`mc#Hy&{%aK(w5>+NhD_ClLR1@{^ zhc%oHTHF8#r@zF<60D=>mP?YSY;zoO%rzrG!EoBEckTflxQ@Vu6Xo-zZKuR4t24Cj z*=50x%$}+NMj~;vsgW#3x}8sc3tF92Q0k_Ox%XwuRGY0RF@=qfiB;3j37yz0D+%SP5qmEJ93G7cvFQCai-Z}sFNJSAr8uA z`I)7vdrf$SJCby;zsJCyIjCqf-U6ZG5=Sh|DdY22EoY6r!(*p$Zq^?THahC312lqx zne!b~Ov>JTK5Wgl;DK@nv>W$6&Ma5kO_PokvZsOR0Z9+{LewAW17(QR>Z1Bb>S!BXsSk(bwc47^4e!{@(^l+yAkfNF}v~VPvQvU#1 zq{C~cMxdEzu8szzr-dwBQ^b)HNzs1D@5b~@Rn+GinbRB$;`JHR8OEhZDXA-9S-j#6 z*|4ff5)|5O%t05@z-oLiYlT8m2HH->Dcqyg;&m*&%9DG z+?_8ZjrI5r6+1s_PBd|D05V1t&0UFNS&EMjl5oJwQ8W~*5oT1UrvZ{7bJ=$T#!Gr3 zJyfMG6Eo9JxTKg~C4pAdRK~A18mmi*xgm^OSwm{wyMisvAu20@UfL@MRHme&^xJ{g zEmKuubhyqV4DiOJEOGw;E{di&$tPA;HouO%cG^{Q)gL-a`-)3L&Z}1{Vx~;pO@`H_ zr-q_B8?o>e1d>S_Tps*Bal9vmAcYlRD%vqTNtYGN z0}4;=4I5jiku*~BWqGK~IK=d_Jsj^^k2PgEv!$G?Ff4WVNjmr8$iPPmNa7@#U1teU zWZ5a&aV1SQ83a-?5XQoZ7XJVcO}_pkgWglDkXxeNk!q5kE@rxL;zXyfoXEbUoGDEC%|}L!;H3}swwqq(MpUn&%(0y z0Z6flBUPq~O2976uIR+vX>z1-fKIbl1`|cE){S|@F^Ek&Z%272^P#YC;f3_@7hW0V zh$3c@W+1?%Z%nZxU6-j^eZ(5dIGNeC3SAG6(Z%jJ;+jIW0wRwTxpW-83r$kVQArC{ z4Ysol#egmBVS5jc33X#ikl6{ECb-@OjGWV#v20o>{#p!L6{JOGH&-rqSPyvnLE)=z zCqxQDTUMy2?x>=+6HHn#Yas{Ckw&hv9pE*){CL%=+9^Z8MOcU6u|^J5^$i-xj|t5f zYdZ^)tnd<`O)hZy zs$3R2RiuA0;EF_=I}M>)OJ7eNHRFm*nof}v?Hy=*9##{1%{@IrlBzBVjn?}78al8QOt;W(j42lS`|!se?Nop&93FJ})Ov~JsjI9|qI^20p8WEi$82&03%?vp}*)LE3b&15alQ8yK2Y=@2?8ADHV`5t3X|W|Fo#Nu?> zVl?f5VKoaQ&q`*jqw@jW(TQjofCByQx?hT1ND4DWXLAjlZj^;c*;ZeO<}RLkkjWI8hb-Wq$_a($ zt)nxBo{m>0GC?*b7i3^Qk7zsyD6Y}KllGc9?nB8c2O1#Q?pe%vKQdx;RkSSB?owJB z@uE6ku-kYin;Mn#IHit?KO&-|<`!=95?n}FoA}?b_VCG}2^5*)W`}qx6Zw4fk;;oX#L<69 zE^K~W>2Cq1yiWUPRMy%cNTgL1W%EWONhj!KhCviaH5Rc6-1EsKihaa@nh~inTH0K( zfk_$jDHjv0f~|?{<}y=KeTsDDUu-E=yJZlG>!&QOiA6R!h#8+~kwA_;ZspnhJ7`Z5 zEvTja^rmUkI#5fC(^1hyDx~;4k6QO29g|NyB@Me+p+8?LHrAU^Aazh-npP=jaacDp zDpR~WP+rOy1+~5&&MLJqs&4T32%|KWx5;^OlkG5~gY@ZgPRN(p+e5T1}i0@LX>Tt|E7OR3N=Srq`rH(R=z_eu)w!&WqlZ@L z3RF>D(~3=7zv1a8`d?Y=H?2nba^&(%OJ40wSU@|w_B;;fB!DSxpb#f%rQhNb^!cl# znMqN*5GtNESmYLFP^x=tVnE@zI#7J5u)Sau@%aXOz6X~AzKV@i75jSX%YieeCAhswj`rKggeEan3QwK#>DrxVG-&o>fCN{S0}?%^!(LU@ zfH10~Z9&ac6!YRy)I}Qar;SUL1noPl3GvkS<1IZKX-{-XrmQkdPM-7%#9hc> z0qg*|_8nY=pkcP3VM;24N6NP#42_p^{yCcP<-%|lMohPcDzZIOSsSs}b7<_$Nwu$~ zhY20J3h<=(xY3ZdAOb}d+;YD#W}Nv|i(<;_hcpXAgiyo?h6n=|VHo;ju|C`1zZC@O zZU)-AWSOB}iD`~rimFj*bq{1=Nm?{4NNl{x-1|k*3z!6UB>QAuwch`rd(nL~p zphgv8(&Ln;ra4)KTKwG9Ov0K$WsLmYNgGHY*lqS6{3BauzBHoR18{cHH|d@|9d19E zmM~*jsyz3SpL;f>8-d|&8;ydJxZou8Qo}RiLZc{BVl%3@sWrof@r&fbKZb zQgv0-WjIk(^<9NXll<45wx8x#SAf%b6EEmX}Ty9A~wgP>7il2A~? zh{~~}&qX9{P(Map=T!v!G$V_yXN48EkWMvV@&wf_1na z2HFl1>oZ2k+2uvQI>}2V23cx%S*OCWIO-*6j>iUPFrC4T{o4x*dr!BEt>ltv6T)aK z&hk_xEYV7CwV+47b~my)+j2V_>3%-k5rrittY`3Ino4|=*Xhx=tht*BW{h8Ln+R)= zJCpl3Nxe@-j)W+G>3#YYmljlv0%__s$cAOTZ0s$T*a~*drWH__c zSrweyYVOi1kUc@*(P4R>C@GJd79h0sAd#RoPq_O#6K+X4Ld+jJ3+Jura3`vo@N6=w zwWY(Us)3dmX8GCWkf?JErAPJLtE+DUC7#wn$iF9k(qxi{1kW5Wj9S9YV-MP*<*pE_RkQV5-~7o-3z zs`Z|2u6^j)Nwv84H3h+d|wkB1+nYljWFLoiCs#;l=N+NusvX zjV^I|s#**`H6om|_Gbjz=+}P+Fj5h2Ur<9HYmR&y1d4r`DI4a?F z9$c7R1uRog%Vvsdd1~t=XyqCb7~jU@z~6=0gDH79idSIjkgBlkA-aF+e;u3Bh!Q4PL;F8rrZh_TA|2t243bpkT6?qv+Bx|^Q<-Xx{UYyfCVn=VyLQ&)(_ zV-G9UPg&+Of*xV!7>a^N?`{|NalZOYbXLDC5|DamCcyr7wB}k!>C#$wA{6u0OSOte zI0{OJJ;u^Tz4)c5DyFW)CWoA#Q%zHoXxdd_9R!CCr!!l7qfE43Z~ zX)~A>FY9JYjv!)-=7enTZtDBV{JG|_6IOHzHg%bTQIx6DXr4h8HWLw&9anG5lcwT4 zBeniKOc5>`WyKVMM29yONV5esQUz8fo(G9-bdky40+ZYek8cfH2T-Et#s;lJ@bQ*9 zL+TDgDOzbNGMT1~Ev>qr6H(gsHUj)3&zy$D(yY0%7Zj!SpNdyjbb~HLh+`ktZ^ zd*xpR#N31I>^L6W^qo$5QPy-oD5|8+^mF0RQP9?6kG*M;51cN_(l{pPxzK~j4&7sA z2AxNX8VWEfn6QlBkzC5Ak{Xy+pk0R40HY1SUdG+{y;!D@mBNJ>%Ito(5X30(nQAK~ zN(ow`j?)=E(GAr>DmN(auAD^EDdA3)&2zwO@d|v+gvN0Rsi|Z!30a9N7SB>f#Um61DBWXy9f;yr7zu;Mo=b{Ru5rnT zVY$+dS)ypz#XNGqyReyPrMJVeB!Dl?5hxE*x;o4p0!=PvI)eI!$~BPtb;~k!?Du*JGVcxqE+psg(Xj) zMAM{(7yu7aLklIw;on=EcI8%+vZ^H3JgrIcxuub$X{m8qNmM<*!7>YYSlIEqn9)5H z{iyL%<~ij{L7bYdv|-eA)i`eU z3_QuyC2Kr!gJov6(oO83-1E;a02^tbtY?i5IB~=Bl`bETVzEVoU^rIQ!7y}EWv-bG z)mwF$wL6)c={>*&uDYcwLOp20*#IY6{VB^g=j_?l3|A7xGc9Y^Eh(g;!swRkO+y@% zRPW`}$M#W679@>HxjOSmWi6ye+M;e0wHc&ET_e*RIw>4C%PmrflnvWi!`S}-$VBqt zM2d7oQ(kD6ddw3G!=RQ*HWSrh)pEmf6v<6YQI6XK?*3fUYw=;xS1Tk?1(|V4Y4ak` zHCsI$97vEQ?kr^rJO2Pr3{i-r>RcGB1d|G?#rj2^@RfyM$)lpgXOX}qK!!GE2iSkJ zfzq%pMK4I3a%!?^F_Bqck5ku4vN&-A3<@o*5;1>v=R>I$;F(x#qUNv>LswXFs{9WE z>GcjA?L^fWboCWaPWKWAo?@zXuo_;&iS2}`MyTrGQGV#wJ5f)M<8rixY9$6$@|cUN zmQ$~{TXB2Hh@{GZ38DW0Gfh}}KT4Y|Q&USpMI56~FV0l=wD99HHPxH`|y4~{{TNmo1X}&@+FQj{{R-) z5Ph~Jcj5~~4Ssa4;c$>eAUa#s13d;`!Yd=VtEfq(pL2Vbs1o>J{2Y1fOlGQ!r4&i5 z{;Mlw{ zTSXH*Q{xbP-PEeMW?~fYwf(moU2Xx8X+6p4pyNMPnO>q~iFPz@(9?^6roHtr)s%GO)Ov{r%~9i+Z1L0gZQsg*f(^S9rvv-m29y!e^P?<@Wlj)l|I$u+ z+^vSQFLdJ(mNr(U#3rJa!^LoUnD+P+%yiv`)SX^mI>}4J<4>JZ$EcdLZ25zt#cwSz ztHDukeHqtV4~Kq8`Ccv1Q+bu9;tg@d;iJph4+zXLvMI%@aoi>(1K*M=IiQv|Vth%I zj@}%z3MwR0H-JD2>7ZvXR;D9}%I?9WSgPDcz}w%Vp1|ALyNeVsq^+4VMt`C>i${iG z4N}M zHsTqAkpE{|I$Cqm`d@{0UsFu2# zdU)RK0?5~6yXs+Yr-`jvBuLmPW#f=(r=%D&FUYiU`6jCtOiq6(kLezCUf|eT%dZ`M z**H>gJVUOL{Zoc~FB^h}A{w5iYHUH(^ta2()&|}>^2`uH>8rfi8z}Hq<@#(ZqgZui zCMQoOFD^4K9@q-7XZbONnu9RhI|BPp30ZKd^?6da0MY^DM1QGxOJWmYQwpOLG?7g6 z(MB$^6CK6dz%7q&hYl^B0%<+NWW_Ud!w~-feG7$E!dX_XzA+)uOk)p`fduKeGX2Mk z7Tz;Og=A9>W|k~N7{TEwvLQPpDo*EFV`9ucu)|(B(tJ48Nydhptt3Lezj40UppZZo z_uD6rZ8hU}8!5z4jWuLr5C$*P#2BHZ4`Rmar@N>YzPwDd7^eb=HJ33{F~hS}aiQ_axFHiG!9e`BB{LSmJ zXsU2rPK0ibu9yS}*B7zZRqidpy_M=6OoPIMmu-~bcF?z(vh8&RUK2-AV^d96EcISc zx}wWTMKY5O*fm8r*$4apso*Q}3if zo)jZiPSNBXy)8AD`93dOg-#juK6OW$ScBM*ZS)Q{@7`*b%YZs2m@4Wes;sSbm>F4E zGdTzTr7UEM31KNA_faP=mTC-2K)Pvg3AycYz+UvY zbfzdllQSxc9sOa7EJLOpJB}#6VG}hPnz*4h^DTr|$DsqmcM$G-r@UC{A3CP+2ni;s z!>bkTEZKOZC=v>9m6l7J&cU}9H`eCB4~HZRQGuY-svyar3lg5BVt4{V;br-_l^7-V zugqD#*TVcbXkcj@iaLcI>Qf#S0I6B2mUcu(YE=(pdUs+2xFrY%*7$I-SdkQ@2&B5y zt}Ri7VpOfVlsZv4jQN_z3XAD~4qifb(;g=0kP3TS)F2~gc;y^ zf0qo1Uge0;jV)je_-fIFNus6WvX`;ZiVA6HO9yEKNmf-zUoz(QxgEQFIpemrgw))< zjZt7Y%x{laP*Xu8%t{hhbg^yiuBO1-h_4b#FxyKq(+e|CnRg7Q>K168qYm?_a`K?_ zYf)Q$$!79l4`5$v-sIUvr->KgPhA=n0BFJC_#PJ-fhizZ=rAJ5QqR(cynPUpF+hq$3nQGdj7%Y=-0syNfwzte98yjBQ@XZqx)J0o8 zbWKN+b5<7(NT;c(!!YS2WY9_)I(IRhx)4hMFQ%LdYaf^fD8YhD2B_~l;&oVdd9S7v ztwxZ^O;H=OZAq-;7X!rJ;P7t4X(*9Iu09gvQN8M38C8qqZkOVa(zKFEhR9Y~*o*cTJNd}9{fGCPP zGt-)`o8eTcw5rkJl~E8w8+l4eupbT)IfJxf&xxqoD6Hk0#f~iZO40;XmPofYrHetj ziO?j~@fW2kANn1W?cF(z^|Z7^b3mO+8lGrjVp$s~50cSF!ha zmn}}-iZOjfC?v*f-0<4vd0)U?|)|% zG=LRNx=Miaq~}#CDIuk(l^jN+-6gEMk&c(J?Q?q%hc|8x+OwcVSfAk&EL6QQ^(j$B zA!!aZh7^@`3g61zmcVOmI7huP0(vQCNWU4c|Ifj~1!w(rwZx%wl{hTpn5{1$wycFV0Y&6H}GKyF#u&I7i%YfC2bd0c*V0a{mTHVKD z53~+5V5ms~m0mOyX?xS`4Mg}R8qMTE{Kk$4l@{T4#I7|zpD4E}mD}PYrh*=_QB%j9 z@ET7u<_lDLkenJQuqSq{Xdm@U|L z?V$K^h8qB=)vs6LPgMc<laixRkG@rDF=--|+uQcTfX&1zi%@_E%gL!pDr4NV14no8X2@fFwpLE_ev;3uY& zpSq0JREnGVy;Sui>sZ9fqH5X+=Lw&4IyR_TAt;f~@GhXi`Q0LGdqhnc9E_EiC1@hvL5~;(gW~Qu& zG<6FcHG89wopu|W4{p3F&n!~#N>0i&%5K!rB|Bz~rdXG!9-#8Xlh7xTnDXsdO6p>s z{vC-24-7I9s7W@TDq*92lkaK3YYKM3-tA|=b{Z7jS~q;xdWa4Uy>wT4?SNNN;@O`b ztHRC*hY)$Gs6?B*sQyX~#^eG=n2&A^ZQcqIwt*{bl}YKM4}@Y5O`5To=L2v_8DVRW zcog@5_LHv;5RV9oam7MS3KcX}6ohMoBG5(uQX0BNI7gYrlV@M3Lf?ST^5TJ1@jsWCwuQ6_-fk+%k)kTWsXxsFHDu?+$E5>u zMGhZ`NhS9Sk^x_hCS|dStzAY7jZFS>uq_)sC3p

D(0NOJjJ7q8v1t+5V*IRUqRz@--hTfuHS%r%uZz9B8TZIrSqB?=Vwp{+4W?@%~>BR&UNhxu;; zP=P!!?SCovGlKgLn})YOJVBSbtwb77`Z_3+^!BB2?A2X~R8mJOQqoMw9d1@v42X5? zMel!a1n&O;a~RPBN&w9`VpyD5jePYRS97yXAVahQ?WqI8{{Rj&j}8^$1k}uvmvP*C zGgrunl=*flWK3$lU?x|TRl_>d#u!cn2O$Ho8oIum zQYwrtj*f{Gsv=&$XhQni-}i~`P5d~cF||V}NEDH)g*dY`jl^j1nuAL&{{SLdRGyNe zozTY7l|E@UJ;N5Y{uc1!)DlHe!79duOsK-D4x&&)qWL%#T9PiQ{)aN#LGOK&#P6hl zBCLc#j;al)aP`E4;WJ{6@X@T0Rhu2LlPr$P3GARSKVKA+gwV?$Aq_QhYw8}*dN%6DL6F@m6-Nurl*L#rKqYfMcgD*>V*9llH4?HT2d(; z!cH-b2wti%YPm34I7h%;#{#>mO$Z3uFwiWpkvbR6HSj} z74YH!taS6z#~jDHv$+fb99fvI0HjucNt#o7*Qb*W>h58~QX~AXfzqCasYUm+i@$BY z7rz+E+|=CC+qD$oNdA&lLl#S}rKm@VDe4QzSMC0eXs>H{j}92PKWRkZ_-N`&mW~mZ za=tw#ENX*p#Gs;hNR?rZ(x67%L+)M1-S=t2buUuLqXwHLGeA97Elo#9m1sUmm@YR? z;pQSBu*q1=t+V$?umw)KpJx`dj}((MiE4}@l3ie-kUaOP6B!D!r~}+>4wm)}IeT}o ziqpue5d0x4DlpENdXY$A-BS6F2&MB^TPeYugYmH^ft~hyPL8ogd#`R3;<~H<)IoZ| zinf=hIW`)ahmuIMG?fVRn-CD4PP7+3r3ZuK*T88DTpTiKWOvLNT&n=6gFp!!xd(G!Q-lS zN=zz_o`=kTc!o%t<40MCwB=f=Hx+?bg@h zB6!ozC=pLRNX!ycWSmth2bcVx<$+}dHx`jBb?!Tlqm@H`DW+X?ltl!X-X!>@HPWBa z#?=)wN9K`m!CGk9R_Zjqr(a;=)`1CCB2tM^rI%SFtf{S3l7BWDX;yWPVxwUUH9_sM z79KoC!ax+U*HlFb{XAp*!ibb_myZ&oLS`yW#4Jx?e;)j8%p}w8D3d0N_fawEtGdE) zFO|AdKl2ZqsJ_RQm{=$SRRgiUhl^Qj_A^Nyd-jA$}} z_0`#I6_6+*qpD0Ir_PR%Drl)*N~fohL#wJ0p##0`+nOsU3SZnMD8{5=SoDcS)H;km z4c{$kr>QU?2^29%wI_Z1Dyi+q6oN`-i`#ICq!&*5v6%XKj#B50t6LogC~K+dampIV z%TVI4GWoeC@~(A;?R4$ z;KdqUr?@3bZBuckfbomT4$_+_Q(}5)B|{96i176WNSeV@x`OGjpAT;+6(*Oh%_*97 z>eV$X<_r>8Dix!rX|OLYJukABDWfD@*piKZXDMn33ai{Z_IZ9Zgh`=~7`##t4K+Mx zb;X;{lpEiUwAK`z+(DYMMxO_#>25`*dAy173>q4QiXr+VFsYdX6W-@$xAEZ%$WpEq z9W=Jl*kl7myAx`;ae6r^mhXfLznWQ80tLLWbM&^nFl<1tI^_wzsqv(y$(<*JG4r6x z0Lg7XN+}~#_1tlsv6yjj#Qdop;)z0NfMsT{gEQcjP_ULtg@Tp{RkoHPi#QF~Tps)s z5DI9GM1zH0=b^!bR>jo1+U#0eU`>$ZvDwpd5}jrLmw;n#d8%U4FySSZjLN76D+NB-tTktjy1a=1*mm=#Vy`gN>E1H zA^k+eCyOmovNfh_t5=5-VW@>G!l4<1#mj}MlFz3#3hcFx{_I%sBTud2tmGw zw{98)kb_8^P?Y)AighPBU^vx2U8E)mYN;vG8mMSm%Opss$PI_Pb}l#@wqas==<4Of z;TtI<(MpUeo@!dCrvH8y@1>6)xdt)ls#=tV2E7c;hCnx@wv#WMooC z`bR+8Yo_z`TaIYJnofnv#R|QA#YPV_xK3D=s7#n{8NPajX7eRdQf6)53|Ig@k7o<) z5in0p7~I?tFf>u}mLcb3ScFo^B+E%i$uh!#Ngz{e5Pvc_A#olNM4V}T)2yjcoblXB zptP87UBlR|b$cjjr7mui^x?E=TSIfAFTCCWqPcV=b<(y_O2DHrm@^hq>AqUS@hoYh z!)YWfL6&mf4x!#ngtOayivYwKWjFVTzkuNi8g}Jylj}y(h7pLyi#|1+MtF6_E8bVx zGdrwa>PJbmkca{IMgIQ)9v|9ThJ;aV<;g0cd(-AGgy7gOP_c<)T7w-vA4&4EI-pj0 zYf7=deFujSW{j!LHG2o*Xe`h8<`;>yaM8rn^;m;cwPeoMl(o*=kzuskPot09GGaO_ zcQ-iAD>61A9wSel<65y#R3OX1tH|+|kLBva?odaH*z<2SfUh%fRHMS0@S1El4Xdcb zscPV8=3^~NEY~|^l%$MK;?~%pSn4@Nf>Vt+$i&j_rV4-Lc;dlVAInN3dU#ZjOmWjd zBkybW@!@ib?-F{b;2#80O=_vJ?AuN$OHCa-ani)hwz>1z-rP0Q38KWT6IK=1e7RSN z^sh1Icw~WBDotu(Oy8xFCaIyNxdi={Y1-D;zX)v}33Vf+Qt(QeCxA3abLJ-&F+CO_ zB`&bIk?zCY^0p$ahieOP=?H^KW(6Dkn}@6&FUk0jsY&Ckg089A+VaK?bg_WL;!{t% zP7~fHTr{f1$wBj?SJn&;lMw1fZJZ&VlAdHSgS4V`dQd_?ZVu( zM7l*Px&uHoP(43k6?kmfdmD;Iik3`Q`DQau8=E9TAux6T-$KUUM-H!*gi$gKNuhhz znmnCXpr%MZVxGF9YU+k01GXvrl(`-38%`q0@NCZtGQ3oPDH(!c6m>G;qWM)qb1- zdl?>Rn46D?;?|T-CW>8b14j!mW}GcLYlCGZ!y=M=IU|;n6_rSG?K6g8-G~U_Sa<>B z!obya4egb-Xs+x4L{NX!+|gAY zDNlx=T9{@xfUxq{WQ%(O1=xZQ-_5YdiK@Ke*;YUJKUGfoBhQ%gA?Er~~3C8z@B2&Q5z zFWj>D@yA=js1`w^5u0i$&Sa>qkh5-PiFTWk+Z9E{kA?N&Vp1UCMq$y$gdCfNOIJgW zRpLzhBcNuYhCRw!UHWO5v(%nsVzFAuSGD%`_4uf>|Q@>vgK}4Pg!u-9u zWn#AO2{at!9QZMerPJI>5S0+7Ef^@kgQSa2s!EH60_W@E=Ng45QZ&CH8WMV+T~~ewW!IYPHV1@1;emM zs3NGXcI(opP~K!`!@Y(704^(OIFU?FHPktll*p1xx&>%JSuDU^SPNVZTr?|s$frp0 zs!FWGl^Tkn-Kb%%nnhP61M(6mJ{pVZ$|D@sgI^Xcam5oQe6BuwU5Xdw#V?EpPgd%?H0MYvy?qEah%=fy^!1J4;<+Y***KbOUUnov! z!xdu2a7mqHuEOhCblD-+NJ|6dOWcojj^J(_hw}Ggd?$`Sr7l_KhZn@j@9^c*9*y?Q7ci;HfuF+$bxJ6D74FG0 z;*}KCID@-;vBK3WxsI36Esq^jSQ=ZeQbf|rsx3(M_=Y=A62%i^XpqL1vP5YNclaN6 z+-}=x2A)_7Ks^)z)MI6{1xrQ?PDPOS>Mbk6pTt^hduveb2sriG4 zqHf!{WZq8eds&I%_S+TZs#A>&{;Dw=*{~j;!#W0}lL3l`DI#>;@3DZ3Y3v^!HsPg}S_6$?1xH8J&DEl|$!yjY}lG`{uFZgXV-jYo0Ym9{|8YPU-9gI!_um2hTE zCWSfyF%n0Nzq29 zz!g_7B`E8yGRl;2qfd)xysgt5x#Z0nEU_!nQBqPho>wh)jxOi9ypo-MlWqqRh1|Ib z*~HL+X+^q0R^Am|n4Wjc+4HCsc%Cm_TvF4R@ccd90Hr`$zx=9Nb2>1F6=G}!?tQ(_ z1+CbjhQLh*6?C^AB}SH1*yVm51eEDI$pqtRKyJkLu>km6PBsyZKI@u=3EdvW<-{P* zcx0AzmJBugpu{+6=c*vs3tL~06W*f%UbS)!X3Y6kzMSFHLJNw9nA9$tkzz&rU92wW zjIv~r6yvS&r4~-0Myl#u4=gDpczy*eLZk!lZ>@~jpJ*Q5S@3iUPTcCIToV|EgBD{2 z3PV!u8x=wjJd6Zv#`gr=T;JKszK;l{Ej&TOgkf5hmriI@EkF9A_W(;q7_G5 zsTrHh=oWCPxJufp$uQO0!Ik#cLsB#(UcxRDA%HFuzRQAK-p{ErhMY%g^qm@9{xG8Nog54o2kxE@~_hM)->5UE_M}yD|IaT43c`E8; z+qIwNsmLL`PuaEj`|6b%Z4BW&X{XgrHva(E%)F%Tl6uK$>Yr|cD9}tn?`yX=m$l#` zt#szdq-8cW5HsxCx+vpvS&Hr5Q5sxZ;ll=+#*3d<3L7z8LRm893?aPp<*vtf+%5*- zNFF*Jc$hQ_tI2SL&jAhP?yr~tr&{yB8&=-i3!l4~ z^}8rgbyLyvspC3vDrr7{BU<$Oo_b2G{YNY>x~76EL}CVkLKZi-B;2e*4?#2$y~SQs zjp|-zhO;Zd9AGRFPfH+;1&BcE+WmZb*|J=x9D<4naLmFWs-bjivECw5FMF#F-y88$ zjT)eEMI6ek$u(4=>flIPYQHWy{?*brLz7{ryiJeM!qCtZ`nKaj7G2L1)p@jaF0J!4 zec^@<7GG%CYHXWtKp-9XO085rj~cuqrTEtTkG4m6WAn@1w8p0 zXu5RY5{8qcnKpVT!_0ALqaJ7tVD({bZr!+W>U?Ht0*DF1gwCZ`SILWE7#2B;KzicU z6!f({Jg5dm-vSRSX;Z1QZnf?`yihOO>Bf^P)!ng$16kJy#=2FTGVTYRDcdY#xV0Sk z%^n$4LrEmLj5AbH#9nEcBVdO9{le*O ze0i`dPbiufx*LeKE@{lLh^3Y$!}dH>g6v*8n3l%>0P!QlSN{NLr|i5+!ksbP#fuDH z3_1pzeQdHr3~~}IcY$+lE=PVa$^k(pls~qHiaM%?s;)SadDxXMA4yM9Bew0XwKYyH z@GAOoE9d|ZI#pr!8KTdbv205ZO8OOw@=VWAwFz_Oqp`o%3DfD~#v2$?Rk}oqS@goT zdd#1WN3@_waQI`9ukRLoM&#eQAnEsVmx#ntn+!>sD7f5DK!*#E7WsTv&vsjuJ0w_z zyf1BdY|^B9Q9HzghRQJcg0_0s%=I5GrV54#TVUBEHW?B#>3frVo-wBp)lVg6Vu5~` z^*cNCTc|ibX~`JG_%=6#FliMxG&L0LptLigHj*bFX;0EDKscztn*75b5R8r8oubb zM4DMi7WS4N99s}5xVx;;p~UeNe4mzS9~D>#!n~)WkS)V})S!)gECC!VE&kMzMrmB7 zG#FvDi;Lz;TtDW-h2|Au$L<9}`g?8%-gu`>CTfa!L~)^S)C{kQWeg`0gbAAj!>Mbj z)B-?nJye11@$bY|BTIyI)3=bMgV9CGw-d&qro-_nb+i$~6-27cM(vUZDn2$h;kb$_ zbw(zwWlRVfffl*=>a4%U}n_PiKb;H(}XzW2@#U(>Mg72cZ5nN4dIc%r1ix znw~AR@YK&*k^bmrm5!fLC<^)%nV^d+W;(1xI$#Md)`ZkkBh$aUtg=nFQS9NE zWCqWb7b!tX6k)TbVWxU)J_$glFe)T!tiTJ#E}$QXJT7TC(Sp_zF`-i+J zfrXX3hAU(29A$+7gGw%-s~S#>ed@8?DzW7c^Hr0Tbw&5rW2MJ?jWqaiN>KtSG}50c z;P~c#%!WF-B#$oPGW@nBTTDMoD=;9_!Ev{Lz6+D04NkTNmmNz$^wX>~TvSn?p0X?# z2{>+5!lD(__lpn0=_Oim<)|Lul5GG#X`I}Xa&@raS^KiJVsPo9J-x1k7!qilX8xY~ zfz26?dcW%BHYJG7Pv=n5(c)CBkfD7M0FuhS&Bo;3{5-bKY*;`6L$75Mzm{ISS~J@$MXg!km5LO2%>7(aVi!F8P)Dr%-jXMZQ;d>-diUU0$1-8%NwzJl}SnV z8cAmwoM#5cs<29!W0Mr36!X;3Qb>|CX*vl|l7x*x1RLA zQgZYvC~B?6D_D!7hx4HAn_-C%+Woq z^I=ilChdu=wAPSfj#e8|#V+veqv(UKNa1 z&li(2)KOuK_5>%FJY}@{Na2RcKvy`?oWwCDj|8Kp+$ENJXxPDEHV`$w-(c@rFiL=xZn6m0uDbu%$M}yk;kk3CxP?NBL`+h$c)Yz;QE<#fnCsY!fp3o>%#pv^ zsC9hBO*hL01J0-~JY;-FshOoDz_7DlJxv5s!mZ{;LdFW4f&d4{UJV&{x%OJ9re#TVGT!vWoYPxhBjI2rUE5EcUr*i(~dQmwuMQrF5PMnDmGmFHT_CdVl>je z8$$HdXLA^4V{Hf>yN!9bw~2rVr7YyHEZ`{Fk)7i8xZ%a(AK)bI6~E=c@WCr(DmLC@E^HVX9assh#5qEU3X419B7| zQs+KqFdqtH-zs)-G&l86(5I+=qfqa|aO@g_q|(Vvw-KwA$ua})0}wvwzY|+#&80w) zX+!pEP=G}u@)zN+>NhLoyfZFh>3~<&QdCD*1k@EZ1rEtK_H_gu55tOXbJP`*5B^K7iiHfA=b~>=)l`(pOO$ZgzEC`r!m4nsBevzb5DmO+Pt(MS&Kn#JI;%Ai*FgSm z{5E}EV%Tm6jAiVpMGN4yUp-kIc$|J~8#HAs2pyXIQqF&EsLsktti9e8pUA$HJx^sU z^@U?yUC9-Az6FG0P~vnLeHJ4NLg*;kbEW^`G-HKtt ze7{Ld%PDB&q=u{w)?hAt&9?7*@pF0GI}IaEi>aBaaPD%)>QAMj|CRn(PrB)O%OYhTrJ?BDKCWj5cMULXqIeK zC!^vM{{W)KAgh1`VeXAd@3;;lb9-#31rKd6PC;_5i6({&kLhpJwnnbR@eDW9-DY9M zrdGmh;Cx1i2vkW8LdZaCg7&u>R()vx32+};vNFfoGEzk-qx7Tdiyh3AnB(+0=#vkc zN}7r(F$jc(N^BclbO!dl{k*61W>T2dB9psh_{U8tF^-J&&bn%5p_O#E?*XAB5R8RI-?z09r1@R~K=gfgZxlv6&^W3=!^UxL@=3J9w(mn;XZHB0i(Lz`lk1B))o=Mb{24JVfD%!c|n_pN(y zZX6AryC^u8i-4HInJ^Da`Q9puitINn822n+B`sX&9Slrf_7~Sd$If`2FlmqFu1tYT ztaH<^RdWs*T9RNCbk!tAuB%c!#34j`+rVzICx}MyTcuxcrN7BvT6R#)fpkMW(PfOC zmN7aUK9wjK;}r5zR2Pxtl!cN^y$>xY~k|Y zIC#RLrWNRfmXcCIrd`Y3LbRwsqeESRO@icFj5DWr6nLI3 zhDR*~R58l5=<)!pB3U0$g_v(`SeuisoD5!ONbezPfyB^`%PmlBsVF5}B8%Tdu$=RU z*HY(Rvtxq|>P{avFG*Q|;MEN_9Stm%1z}Z%K>HDZs^4FJKbc?JDJ3lsQyXj9c3*fQ zZX|=zM~5L}c!-XwNHK-RQQXfRJw_cboPmjA0~8EbTil)j-eDx|p*n5^4-F}C{H>ZX z+$ysMj+mOPRtae2n+a)RQzIh8346 zahlW-%{27TQdiTu$xP1CO(d5?DEHU&nvv|~)t}p#8ijanz1UG92iZn0KTTbF%orG} z!unr7^>Y%9L|C7lACo4i`-2i2QiHhDP9j$ES|HA`RsKYQ5<#22Tv z3l1?&NdmzO#AH{dX{-qkwA{)#r0*rBpS(=cW0gJ?I!$qp(KlYO%wlS4+^bbBU_0TU zo}!T@mNimA3esIcKJL71?lO_LUli+uD@X`j8ax)8Cs_o0r11~G|0OJ z4Ll5Xvt723dvS$l_N!C{i4@_=-$Y6@*7Y_ zqTDe4aM=`*HcQow3%FOJ&Z5Cjh_*RPIK*nIi_uX*3G$;xO{6CD9;K~&5%N9EW!T(4{ozXHfXNIFqqd7#*0_OQ}bxTo~AZf!nAH~K}5g1 z#cpRHfCV<)l2T02n~(ZK>qa+}@N5P=u^m)dewXE`sH3Qlb4w(9Ue0VSadCdbPW&o4 z>j+uYVvO6faH9$b^5>wQw&kH)G0X5sWr}F&U`n07RYb9r^2;3v2fetkZwoGr4AM`? zxRrRSE_n1q){N7MR8~ckV@9Zh$Q6}!F@=G<6(LDGfL<+YH*F$mm#tQ#g(RW;I{MNu zDvC*Apu=jbBuUbDGRTO)tKE!3_qw0Iic_AVc2YL-)to8XUqW4OuY(H1PANf$)FPyE zRQYqr-dd8+WCr%J7AK7_JVHq@PqLgjQsZp_`IGS6^%+Hv3d|!l;q`PA%@b8oO-Enn zG;zwam20iEX!W-Y7~VFDV5E;_GVV;Fh#=54n*RU}-n!v*mDL!HT_kArGgO%5q_0wZ z*$j$`&Og>7{8BfGum&FrN^)loG7Va1;MLPCccj^0)D8`vpjuo;yEEYR^ddEV{##(u zM(TH4xwXHiferV$L(6GHfc$9JAhug&z-#}|Yy3*FnyTKOblKpc7170AUsSP%2$c&a z6IRB|z?%efeLjvs8@F&>bc3=!bv5R!XhLGD^C#xanGR#aaEh#QlL*Es@aUq%-g?Ny zGVXtNRgzM>mAhWoxYvUx?bjVR(OV9USm8&fAmVvSMY88?9iTDqkA5kKi?9HNH<%m! zJVfJ4jg-5+PfZIL4sFTw_<~U;Yr~o1Wb-ML5}?xKL!{Q$_tfyM%WYgJ(%$z>5Oz@A zg=g%&MNYGSTJUs1w`6hRv=cHn{R^9gk2IwJ01YW_>%AmR3|J0u%UGbLnyWuxwB}S% z95tA}8q)0qn|rkfz+T*Mx>RB)x%VMjL8ltre=O5g{{W)q>>{EFY^yvNz7&eZfHxuP z7eRhq2|X1?)R37bxY2bZDA7$Ebs47z41(fW@r)zhuR(OqEI)oFpRihZgK4!Y4iSH#PLXXK`tEloh?%UfLL!b7{geD z_OHaJFXB^;Jge1_6BL|$*^^3Q3l?a?rKZBzM%4nkk&G-ru)4@@ec{`hEv$k7rx2qf zu7J$<>JKAjNn@g+#URJyXG(c6>?H%|)?WM`U3_0tg%VZ##G*`1< zseD$KHPOkC@G7i34w@zvvf~xh5UoIWHen3&ivg~qzi$pdZIs-E;(7Mbt4`YNDhHn` zU1h$wQD%r?qsQln2su_a23>25J0fyRx<8#F8%B}_lC!bnz`|C#2DOCG^3d@M~ z(+|p&F}79DIA&*e43+eF9c?VnD=LKmw6cq9r+z3Gidsc=;7_kp#v_VG)Ix=FxKvXR_1Z5S)#O!=c5 z$1CwXQK9SJ1BPId0X817;&>}T2wfRKNr`KL-{Zy~wYqa^J|B&4+V0h`F~`oDGgnx0 z_7Rh?tfgO=aLi{Kl&Gi2aNI)=Vx=3*6FSFG!F$*P;l#+wE(h?K^!#Z{S4_CQK~ySb z4yt52j28u}uFd#;Ag_%@S`2cAUn*o$&AbV20_{3@@XpfFK~S!}m!&%skxs*D8%d(ugo>k-d=GQ_a&C}KDvd-+0YTyGCD z30BNl4>tDKURc_wEA5JLE-O|hl2c|rn?Mfi;e^7-zGJD!F!i{wAH6rka_J;t7}Zn? zlLu&|l=-`+70}5YK6=7{gppcf#&GExHn(H8V{ZODbMnh3Vzk?Z2d0o!dCMW-^TAyX zY{BZGjE0pb#&E_KBrc%O?*s7ScdZqqk|@gGGSz`GOcUlTm6`E>=RGgX(XKy&qT(}u zF07}XdI?xXBt`Hy->@Trs%QkR+lSd zlqF-uFx+OUng|@QI~o}(S$9VziA`=h9^5qU`YDgi6($Z8;N3#Xa7iLAXTbf^9o2Dc zGRMZ(S?#U3rASn4q-NbGVXiXg{FLgoQf6!#aV^p^_{J8%-*W4D@AZ+!t;&JfR(8-U z8QDoQ)NY&7s|j;%4WP2dF|0L6Bk7-B+%p!W;}nMBdQ>r_o^R@2NSh9wTN}cQ`F?FQ zgB756Ww8oL6C19)M{#0SHd2NkNIPgM^u?HPgwI_@dMdgqntV>D2a=jhI$BzR8;_fa zq>BSSpt)ejh4%>!6zdyJ7^rImpzNtXi1k(?y*BC9RMd3XmLExv($3J;F{hBS;n;(0 zM^zz@b&7^Ik z0at`{+OAqUtS>p?l0brJqppJ!pk|0VsZVsvwSXr4O8!vdIAUt;=4b+G4VSZycB7LO zWT>L3!DE@Q+&;FIAa|;nMV=TMGUKrY*yw{^Fm_vXMoMVl}hFOvVLppDjqW41lO+_n3TcZ^OHX!)UzR#= zE?%U3R};bM(jU^%VUuHcL~_Ih!D&lPeOQxYt*m$ycP?A_s2^<`{{S{kvW9~+tZdcN z9J4MWm~=P|WY9CKRZ~>qwX#aKEwnUSiMhD98Wt*GY$w*9cKKHZbqso`1)Xyy7oKqV z=y2>BS{j)X$&lf7G14cI<@wB~Yp%ZSg^zwG8GD~~D6(1-VMH1o=&Gskd?qO|8EL6$ z=}<^gqPmJl-m79ui3zy-xu-JnRTQVc2u#fv-l1l0n_?A$o=I@*OwQ<)Ej@i2tVl)e zwI$uH*XZxY)s;Sz;T-#EUA|`0c9B80d&DwM3sZ#Q`F5_38Bzq3`PB7zY|%un_u34y zTpKQ`c%jU>&;$cMf30X|45(tE?4zmDjKP+%Y&Q|6%-vec*p(%0bk%}5@vJ(UG?8Oi zT@WXvO^5@vxmPmFi2F}Iw7t8laG2C1o~jz@I<ac&WGDR@6sU6{T3GSKK}Hu*w~5=_X>Ps+TWk{3fNSg3a?4_>C1ezV-kpo>aZA z0k!+vmRcPkz@}emC_84bV;xiJ#vvO}VmZSDGlY^Fq>C5BuNu0Q7yUi0@V^oMQN;{J zKFfe&DLp4qa%b|%5~n_3kVg|k0#Hz5ctgLGHe23#$*|J)@a0{xbx49K?)d>yHqeom z`j3?>%sYCYfi*J$2ubnWBXU~yAMZu)rx#n|vf|-7t0p7VJgY}CPd079@VeDd z94<429UkFZ{pdT12f6U#hf=gB0W{l13Oi{JjP;`;ts6s^^R5o{lx11vpA^E{IRihw zpnSl!z$bw_yLX*9Ap59GWR}ylSbEYo81)GnQlX?w2DS<}iV2NAH-sxNKKYQ|q@S~) z(?iCEt>(ak?)+(3O`-n)Todb1WA!bTjw6R*Q^Q3Bn4Ls44_Ov3g)}g%jugnnrct$T zbN!q)w|47cN5YZ4XKqHIvG1X|^L9?E8!5An093Mp9C+po!L&M&^FL1nX=!n?gXt1> z(r+3}hh0$yB{pclCZ3qQbWSns8DtxjUdB3`kU-Y{&Qt}S6sR-;WSl92Y;y#mj;=gE zHQ+Vzhe;`y5X=}=kw78!^T{OKTZxq8$^IXOZW+`(Um8N=xq~iEm8z+;UTn+rEl3qK z*m%Y01H}+xMcdCHwe8!9TXFXiJUG*?29U1_r01h7Q!ipz{{UL2!LtQEVxy#KJg^Jor3o z;8IKn6PT74BH^F_Tfp)L-Sm#}QMNu}rknR=AR5)L)XoEk{{WmZ42-c&B{ed{04g>z zw3Y==h3&~RDqN!;nhxJ5$0MSPJzq@o4kv#b)Z-0jk z(()2OI8kDnIKiimkMut?bt@|MBNl@btfQYOJv~ECC7dHJ*$lDn1ZpmZ+-Camwv?PU z)$A>n>QrZC1C`O{T&Y!w;I&nCP~rlp#q&v1GM^|$mMQ~V-a7EaA+><0qOi3$gql>- zQf7=d1Ctb{$LisRDQW4Y*-M zunlW!Plpb}3DbxaPHq<_4Hz7&)7sqSm9VPx#U>clU42FyH=R{buEdmOxQv}F+%A38 zp<6Jc7MW7hwt^hbm2*A;)Hz7`#T zaHA#Z?=p02C1QAuH(jf9B}O5DW)qBHYn9`YrZ=Mb2vf_DnuvvryUPn7r-iwr3tlaO zvm6B)<<|*7R=Ei(_QA4S<#vlNoAEM^$xrIu<6%2@FET+_=LcwDNi-IYXsrgI)i&3V%TuIScp$1zL-ii${TrOak}YM5t|wt4)ZJjS{x zkQLWU+k?!a+&0gqPMx*P4?rPqlN5DdWfQL$2p#F`3V!1EjY!&BB)R8i3G zsHmO^r7E#3flGa^-uD%&yPQDwQZ+WPCQVGucy>2|R&0+Kt%cp0i>+jUfx7GNhSKAd zWeDgV%1-j!L6A*7WQi(jXtBz=oJyuyX@qa(y;Q&vyc5}mr=ESJ1ArLyQ}&k%P$Zp{ zBjY(rrx(MY63aDsj1{}gMx85XRAHlT_nWfb{7wo|V1Y`O3WY;_A2s0^WfmA~s#dbL zSmSz#YNjk?bF^8*`1j_Mpq+xNBn(Xps$x!72O}uMk?_3Wa6~Azm zm;(VuO|(!%owdt0(bgtmsg4@yVt`ZmGE(ngvAu$Bw_)~&H*cd(BCNerg$SOUaje&p zG2ES;GQMG{!ZS@BRa-?;vbzalSfx`G%HHgeNIudqAn_h&Y}{F#4wYqDJ;TVM%%4ZxBG@#EpPLo=y2A0T`G|qLBnVb!;-4D9fHYPp0F6Hh6{3l`N zXi&&S(ho?geCrpaoaNGfpy2s87nZKOFW19UTZiMxEUO(*^4*bGsnNh4kJaJ;_b<&* z^C3V9=cHq#M|j0RDTLej8Y~{gNpfWQ&&+`CRP;!No9}#3BPOj@$G3aBC1<4 zG~NAMn-QL>mV824Af{`@zD71Ipy_kVKpZN&cA7I@ojo*W&Z}e4S7N!Qy9MdK6E4hF zvX*HC_0Jg%@>E*bNJ01HAgp6k?`=|9nBTP8a2WH|O6_gjTDIX<*`4~KlX?f!s!FLa z*y-V-rfe4{Wn472>4YSdfm!!$UCvs0n3gBGEO-ZLgRiQ7Pc)KJlSxxkEp%}iUE6MgNduBTgT(GB334D-)2T?IqoA2{ zFJL&9SA#V4{{S1sb0s;d!mCaN@~{U+ytfMiuSR0WHlwb<~s{FNUJN06gS4FR}Z z&zYk?jQWlA^_OX?W5se#Xn|-9l=Tk{GROwW3`{NaLgMS+iIHOA!~u^`rHH*?5)@)O z%?DWbU;Qv=JQlW(48k*A8rH&T<(cTp`?D{-+N(>CXB}@Yd@Eqbs8tQ^sZI*_njtv$ zRm&Lmd8o`;GZMt2%Hp0Hd@dYbSz@XG07r}Eo7nTMrS_*E?hLgKY6O%(7YP*t{{T;eVXrZwj+!h+zsZ(B zPU%|f-#|d)A!!LDf$XcTN-jjaI+)tPgj9_EcR%|z3>QN=wpjVy=sp`QDR zZsc;Sxg7)9S3_z%Xco=cFZ#8O2=Q!oSYBA!78oj=m6dxVY-?Y~zYJ|wm5qXuT_B}f zX&;xc%B*J&#pwQetInp8Rcehyz9R`>>^@M;*2Q(pCN=5la?P>19OBNvzBz;!Vs} zKQAxhF}jQB4Z-9MkT(|u^?d4R%vLlc3f8OCo>Z&FGd(^vM2u2MDd1PJ1Ux7W_0q(* zB#f=#0S1HDNHa^XL|rn*b8R+xSYZz~7h6g56He(FhAE_#Rn$m8AY7g$-V3mjo`|J+ zHI})WKa`yS!LptW)@ZWrP<%SS2&>F-&``v-m6oE2G@Fp@8+^tjTKeh25qza+owG+q z%`NJKg;D2TavDdQ>ngDLnxS4;VT;QiNWO>sLBMv(KHo!K`Bs4gMW+OYz{{R+w zP*cJIBicdJ*~dXodydgbOoUWEk#v(0&iJifCj>k2>?>_7x_^|Ydp^avwZPQt$8T?f zAav7K_OfJAxap2SdR!A16U6lG1}h?YE)MnbNLKA~EKT@Za`;i2TWW|AM02UwEpA@w zMj<6NRoSW?0bOst&PUwV;nkrEXmrs_&5-sKZ!%X(Ycc%WT}UwRIq_AeitdKU)pT&Z z*T9>;pB@t4UJ*vt?1_`MhVMt+GE6V3_`U^SL|(57uaabvP)5@bWz)m=bsR^XUH-@s zvXbBVuT1~)weVjaRHt^9}^3yUXJL+y#tHPHB{SDD+ww-Q7Yi0oa zO~Jnv*}te0N#0^Gpwj}wqlAW}zVi7=AWnDGC z-NT-_#HB*KmB=)a>IP24Yg-e^e^cTqY&)XDRg zP4Q{)3~n4p=dh~y(|BkYZg^!!1zIz>tD^!BZe8{peV~PmBDZehnpU83t8Kx(LS#Qv zxeASOjJ@)CvXzpPH((1ghohUz2x@6J4}KCzVY{}f#^4hiUNrt(?@9^V^5a8GBGzKp zhXwQHRok0=Bjec{sQA?uF;KXMUBu)##$Lv$6LeJxJBHZ9!O(&jaBFXyrNja{C^Wpa zNn9E*Ju~SY9Ca1&$qS_}A%)k+D$)S5Fpj$q4PwNNJCCD@AHESMrk1m2b@fpj>IX}z z@T~ocBE!C(YCW`3C}1vy0b_BXAPsmUv%Qvu2i~_*NflxrgMJxTfK~d&l&D&`;>mKw z48Rs`t&Cp8`vD(U0llQCDTaunoz)}0RT*zu`C@z{F4ber6GWKaD%gB!CZMpx>zti_ zf%P5)Hz~<+W2@&vo#RLiBhTb&rL$f@m-*V#MN~Y5z_9nke6VCJWvZ+pRIb~V1KFn~ z#x6WFQS#aSq>6!wWGps=C)Y_lWMVNz3AEvNyR$mjC}V9csqM?NaC^$5jU*z2UW9ZO zuRmkBwkeCO)LBBBeHY`icQxE8;^CZR{P*cG{sWR{X6?xdD>WyQwIv)JIl zaz0nXC@{)Y!{{SVkioDzB{9oYX4qqc_mUMl$sxHU+U1V`t9e%|f$C^p8cn)EJ7}Tx z2PR{^K*Vz-*qu|<%|ll$H5^invB3ht9E%)DuGCO;9zD*df;&Z_l%xtJxCO-$cF|73 zG817~hBbpqtUg`8nbVR5wwvw)@;p2I)QO_v)KIUGGQ~YcM6IoZCS&na%YOp8j-ziJ1H@{hWeQy}!kT=s zM_W95M(Nb7V%n_Jc0N2M%*-gziz66Gr_5h2e8m%pfidrB$u=6?AKS#1u8^u-nWI%Q zbjJ#gpC?htyt}*$Q5a&P=gUM}d;uN#?7>o_J8A5k!bH*+sI{==j1GF*l4hxrrEtWj zYboC}!ZO-;D8JLgOs$y$D4#uY6ipnwgO-gw1th!tw2~l@wYA*IrOo_Ha5;Rx5eKG( z*+L-|)@#V~*Yy65YKWLsycl$qd$#WLTCN3RE^XZLHeGT9u}U+hC7GhdQI+bcC(cqZ z0(y06W-2UofuykmOYm3T%7paLAG*NOZw<>8RFzptnKwIB!bQ#RbtdNE@l%fi3{h&E zDIoBg8gRUsRX0{BYbruh#aRSY!+RA4W7lcFw){f3Kty%XniKm#O&%#aeT3oowgq1+ z`3VwLLS$tuq&*w3*2ct@9lksxdH(@`5r6 zW|b_Te$E`*;=)fsq)#hLgixW-ET1w?(o(uDRbCkJOmQ=zSgRpcPl?@ct6qBj&3JGW z-I{dH7@8U}u9#F}R8zx;Q>-p5s_`Fm`LVHLO|5k+#C`Z1X=7nZ1P(PbCgf}~mY*@= z7}g^m4T4}al-SNEiB3GnNETV(k~onyl1UwuAOpwY#Mds&X~t>h+tWlZ)ZSXE!Ld9C z7>0q;lNFLl>1me!eb|OVN4IFye0Xz`x(uY!9MBO5g<|O*P>UUt8Wc$4YG|UUsv8c& zD|w8AKy}i`w-jHlB9Pj*Ge)|jCc}v2?e7Z(oy|niBL4uAse~Agy{yAutA$8^$3`kd zrf6a4t_cny>3`G)Q>0HeO1Pw4Ffl}AuZo_ESqiJ^c1Z}m{5V&bFZ`vm&l+E1BHdtd zs~r3ua0$9$(+;!H;k64rMq!UT{KTj@Zm{g~21_O!M*y-E7yYdmq01GForc33?6|S#VrIB+65gk;r zMN27IX^p{-L}g9H4#2M7$LZk4&2kMFKAdR_mlHqXtD2}XwM_I_O>x5OF^F)}v`A7~ zqfTVosRQ0OzZ5(WV5<{UWI2wWG&*IP?yzONtDCFv+{oA^9w9`TcNC$o6wvf3CrqvkkWXtnoGOb(EJvDUB$~Lp>k9y6v=< zbe^A;F?FM&ZZw5+R*Nm6k+(RH+xkkqTS?V%*=?6*B*eK&3-^nMi8(*?Ft zc$yx4HFSauvC&Ky7^r~9RgTRDYnEAn9^{iSQDStwWD)TCc#|@|E4b4WJknEbqz4wPyz3YaMUm{jHaFMf!xRq+e5kWnB*j*Cb)cIT>MSuz{$!O^C5tz+ zf0uK?D+`9GmBz_)*0x*p&(rLySI~SmTv7{HRbo|HezmsQqkrY`$qcH%U93WYJTyFx zGh3Ahl@u_rXcRX5ajtcC-iQ)D5%_S}*?@tw>uaar(=d!l9wzkk7X^Y(vJ1fpw zg%i_7!=)KZ5v9vAQR4KeiQ+g+hK8;f-M7b0JaIC(c`Q!UKWE{`9=RI)>9kp>qBx4L z9<9SflDrkJS$8!U-oEr|Wpx(6dkbs9PF_jGP=4S>6piU7ON$oA(!XGpuhRN zZyI!bkAT$S`PQbd40)cKj}l5HrjTqVI$}~mYx|Zvk1Af-O@_A8`!saImaeB5q-r=O z5@Das=Zcy9&6bTDX)+xTzAePbxs8ucV?X|x;gJ#wHGM$IZBn{)0BRfE)EG}E$8 zQB#RwUnG>`OG=MLYSmx`6IQ$0Fyla0 zd!dpVj2zL>Dq{55lwx5bZh4_DtL56-Ts^@&Qp&_qN0Lgh6ghO)r&PF)Q^hy(-#&v1 zl3ZsHeHUs)K|6l;aJSv{aTV>>hR)&vr4SkDyG7FBxKjy9DYTEV+8Mvh7UuRS;qLfUzF^2_YCYfmSPG z5BBkO(`a>)79<*G&BdY6P+--abiXjCRI>YJOw~ai9hm5ha!rQs-z*agB2`nHo5Wav zLGU&{2a%=IZdp7d6dE2OZQeIK92D*{eqzeGj(oXQK(w_OZVicIkYaF!@@mnsOgygE z9qu<>PNK&BxOiPk(WnX|3s6xMPI~o*D&x3DD@dtHQBz4I4IGM~ICtI&@B`i9)>h|) zjucmzqm2zeg>D*^S&!806>Mo{G39BVq z2$m>@?GXvSpGnm5Q*8#(q+lr;-Yyw5-+)omVl{czrbtza;u64`YTIdGHy#!?;)jwz z1FERm#L+~|SX~V!Zu3fcBCaZmWR3JCwh(Riju|qoNfchr9?8lP)UM`-Zz%j zYq+2wfn#B>hXW-E4oFrsc9KdqP$!xCeT-%-w zKw7`tOC>|^B-kGTZ265@^#dJ`e`l!<%usybdg4iO3BMlE{p7vY4z1H#*#Lt5j+tc2oDRt4(_>(fL`r0P$nNN!ZrlnD3#x_>~`AR3*9yY z#2OT3PQxNL(SVD|%w0CXaT;_IHZKkl9n!>klGoCwk7Ij}tAw`6D7cC;z46-`2s1}b z){isw4-RSkq^phUy#1T3$q1&kzu>RI8!z|;1lG_>&NLHanRw;g$Cc>VM$yMskguBC zc7$7L@zTI>!KG?R@}k#HAob9#oNx)KF>IBIP}3G;Jv|Ka8@Ayzs0aM4JUE>X10s|- zh}l*&_ys;3xEss9whTrZr7+15bdEuVRX8@++26x~CoTyc281j$0Too8PRp=Y`iaYQ zaKNMI#MBZ9fB;4*nq7P?uACCuIzuGUMbksSo)os}rX2WABUeBpRi2JIr6jM}-Ca%Y zpQik?%aqMklpRq=KMl&^Xt1ghjIvg#o>sNDJErDQ?65vQ&JbL@La6%PuMb@yGLBKe zE3-yAn1wpjoUa6|)Uz>UC2L6BQ0Pb>WRa(bA9dw~2;)eZW?aXG5YJE(#hp6imoTa^ z<=_-zYKWnfc6iajxb|FW!@Q{IXp^+jZel`~2MQAXF=bkbG5)5m8x&qdanMCD^6prH zP@$LEZhJIy!kVRvSeT<7LxIUnkufHz!-aB3EV4+b0<$YSZ3OGCx8Xuv@rpGJ;nz#N zgVCyNXQ%x}lP<$G4hxp5a@IACPl!Wp{{S-$6ceEfp?3GSf!qu6746(Ql6Z)#+uJ0x zMIRr-ZzW>+e+}y#7{pGL*sf!wtILzrMzOTib5Q<{PzP&)YkW9Souv;H)AnmENa?Tt z)KY#T_{3);^e&J{Wtu$CH5Adp!~uM{ifw&+-9fnI6}#$`o|yU6-JUg}az5F@s9&md z_1LU9eit1?6yiF#E0(5Zw2?l-vV~*VFbi?;;L(Bsnjv^<0+`^%^Cm~e@vJJAs*-Aa zQVb@ZuA*4lQWYetF{*_3y901I>xe?qCY)vBnTlrWR&~wQ*$*1awRBR&O^j7h*WuN# z6tM{2l*puj!uDY%oKs-J0_0MAw^tM|`eDN}Or0FZb517%)wLEsONT*F7ke}d2TzIM zCffC1m|BL@N0%1KC`jQH0B4F!9|6N=!LXTWDCvU?CoWN=i#<(0%fe6v&;;BUZ^w%* z(xRz7GgWYnF+@`{;TT01`N3+8L`3*zD_ctyD7hQFsICW&t`C221nju43~ZqLnq<{r z;q=E9>fRg#LKLO0hAI4`fA?=Nn>T*?a8T%mPn8m&0_=2F%U+t=qPh&jl_Q&W5rR*M zR>etSxJ+V&caMlb2hqsqG;2&Anib`)5=v>Grg<+G%T@W06|bv$oKB_j96f6$O@=Bu zYO>MD0RRo<%W0;(v)4M*6T+8U+IMIqoN249qNfhZlyz-aO8x zkPQj*D`m}jW^6`|I2m_*%@PP(b-No#Py7!O z+yWqx#+J502OX79exhhyGc4F_6Blr_HS~@^3dvPT=G*FUM!wDuvYZjsKzqaivas}L z6A&~QeLMdEq<=AmYNWAk%CNcHe{P-lqVP$YvjVMaFLdh;o{(cQ)5}*o;dorWYOz}sPSzi80% z{pl(bRaLwLO*kbrMm3J+wWDX4&|%ZXRH;q~Dq)BOa-i6f1-^@N??OaU2En4CoifWM zCL>WxPZc#W!`-HZ2GV4wS7*P)2(xhF-O^yvCz}LO&!fZZaNN0rsMF~|6d&dZBCDp$wIZNTC-Z75wX8`M(@OZ8a_UZR3J#v-05U7K~Jrin`{ zldgpKJfdCwnT#n?k>kdVm#2INnCF3*F;$FZ+VAGsbIh$}0&1V?{cyF3(`jWt9}e6n z%v7S^T`FWss0XUcw6%E3LGp_&E5lNdt6Z5R{Vb^Zc!EW^WYgXZHqs{<1kqK_S$7D+ zFpOst#G>6^F?tunCyi{050+k8Bx_iEvF#S|JUU^?1PU%%G_IO*mTJd(VVLN8nO?0# z^lJ6A2BPZE3#!TGxYqlE+QfK{GjV7x5KwUx^KX_{tBqM7OZvBwy-8&JMQR~zFF4?E zHYFu3GwztisuWF3&Ol}?!3a8QwY(1lE@jSIxur%y*+(k9OX&(5c+n2^D^Oz1uYu!u zG?-O-2=d9ItRQTyffsyCZ?z<|1F)YR2?v54v}i<{CcL;RG$MW+)fBi6W%U;&Tfh1( zK3|e(S9DIm#fcRgPjbYIeH=r*O@|vnt>mgGbb-c%UtGDNX6dd+z>XpQnH zGpbF7;#*%%zy`7UM+1AAYNGQ00LA%=5ofLfg!$2Q%Gowde;UUzYU*j}vd$@n;gmRe zq9z8asEw*#XyYdK2qYWi8ZPS(dq6aK^rby?8Ma|XRJQ7`P_RCfW$AGYMnhMQ)AW<(ZP<6iN?gI9j~__5)2vKMx}DHwFogQ-Qbb*mL{6hd-tIa{6c7GunK?jmX` z>q;ddhye^yD%eDUzQV6@Z=~zNqF74}r77V-#a%7cl`D-Hewo2TMOlc)j8scINlzr0 zaV(~qJ2-Z_3ldvxyZD2|H$ah3wxSI#G6i{pn>k6p^i3;C3&z*?#S}n-K00wd(8PID z?71Y-Ue1`EC1z%Y<)vv`%O*67Rfn#;fO@| zoYeS{se(yT7|hSLhQXoK`0+MxffV*!7G!a&Eb4v{jN!PAe7I#qbh&b$FX3~+httHs zkD8?=BXlf4B&lXTC&OL?t(`#-Ml(W1q>2nM+*Rel8lFW>n5`K^bWvqyk-hgLQS2XA z7I#1{sFf0$18e-WtDPluwAcA(u>b(OSlns$hYZn0>sB;T;FgtgjH>6#c=0?+pJ;El zd{U!U2kGI|VkoFdpraVW;}x|v0sjC=GclSnZL|YmQ~~hfgs8Zn}k7EFf_royY? zVq|$L1nfX4Khq@#x4?c}O_%|;pRjNsP+#g3El)$3GOizoQ+cnQYEqcfsJx#o6-vb+ zAbo#ORc$)o0;5gB) zOh&`Pirm7ZHuYB!|wMfs;$oEwmgRZqRBxFb&vA6bCixD*}C%9i;%WYNv&<{>5< zT_;Z}NRkRyn!cJj{pB?AqbhgO-L&9yIYjun=tsNP5WN&(G6o_rOuL!#T=D~1gkuzV zt`(>|D5`O4dWft?f-@2Dw+WPjrx3mzee`W`q@}f_(xOCixRRiu^W$uqg(Ll2@rg! zxzj30>!YbthrMh$TAlD>f|9a2`DRsXpO$oR4ej4f+$2WYG}Rj@*;Zna*S=e(jr@y> zxYC;5_5T2sPBgZJ8;kIr_5xB#=%YJ#^(<9&XDk3zdYiy2Scig!1~NF%tiLL$sMp(m z8`?YmPf1-)r@-JTS%=Y3)Mxnc+Ef0Wj4VOojCA06KB)xia-zh-Ev z@Q(6~Z>4mSm#N)M!fBO-W+Md(QKdR>8_Lx)3wtas4-@93_erbe!}f-ZWgPP0c*bGM z6;t_G%ZIFJT&$Gs3Zo6%lH%L90s!yAaX2VZx|fVm#p&iRif8_d_2UL?BA)`OTu%$i z#YD4H`Ns{*m`{^dh9IHY-p)|_q#hII03qa=nWYwzP(k5BpQ8Fa!GK_WL!-rOTB53- z9)W}nD1VX>P)8F}Aict*vAGxTy5qkqcA#PeRRN0s)zA2hMrrV#k3}S4ftkeRY!SW8iP!kUl_|bz`gMDt68t3b#!E088X+UawHNw1XeOa{U~q&3Ry+Kn;!BP`0@2 z00#UXShN5pg73HjfTJDL%-NH2cU7~NGnwfGt0f&3HUhK2CQ4~t=54`Ez&5_W9w)kG z#j*lTEwp{KIA)l-*Vb&cn6k!W!oE@p%B)5@Nbp=ul%r714D$JmikcR5eY)}dw$W%H z&z&N^xk|)E7~e+N{$9boCg(aTth-s7D_b`pX)yR1p@mKhOcY4RwT;*g=I4cZ(@Hl< zgBX0x8fB^fBcs{r*0*BslJaz!6bvir3z1xuN#@v3Ub7u2lSU_C_akMVLc-(t9Ntajz zt5MoTKXGjM-GpjM_zoN)q>dDr-D4)2 zbB#7FHYe07ZP59+hAUlDBcQy6%n>k={eWAKwGf`FNZQsdtiU~Q)amkxf$c40(qCSLWefHEdLnGG@gR-TO(Oh&e@2(b?^qp_MepjEi` zFa!Je4!CS80ig?O)3a?T7pS<^Z6#$TO)Q4KrX|3sBycu}(m^RNVXeOYCj6=rsT8Tp z#}=5Rr>LwYYw{OQF>Dr!nvSy&t*629Nh<2rDw>*StEw#F2_E1m7X5|z)vJpuAlB5- zQbL6gnm?bya})f9YT(uQL@9?;lPY${vYaN8_oo;%Q$1AWT8z1k zbmtYRoK%e8l_)W_k}GWtDrbq7-qCP4ca$ztuRoO)-5{k@jp+x=(cw=%#Ew+QsUBBj zc2s&%artrU&}3Ha)&L%La(z6@7_K3d^6n{z)EBIa1)+|n2}uc28p5hc9tBm-yarx6 z0*vgTJ)rOk2x_UM8819XC3uQ=r>~AWSlF;Cw9>{j@HS0;o;yAvPCgAbWwoKeaVofQ zEJk_^R8myaR8l<8Gge5JV)7g40luF{9&i$IqOlP{)^ti*?1PwvMJf|d4Nu5Si+Lle zFuO~yimmU1qt}{oC!obJgrvhGbgT0T znpP3GP@=(aZF`OvH!)AGa6qIsbgPkZJUA6+}V}rDpX$!IJH@`9ow62wQqypg+M|L87KmwLN-jzsY8ub;8jFY%Ug*obmw)K zeCs7VaxnHC+kU<$b%Lborvs2+ZKuwjq;;|3xo;Gxj+Zp5)KfuOh!SLwK`54VPzV=g zx}iQN;mh2%Qgs1^X`!e`8ZTXBf|6{xj$u^s#wex6X|UMqB0HIWQj)Z~CD)bNu4lUZQx}S|I?pQ-XsQK7GEBA#-av}mS52e0Tz6 zo{Y0@4UziMH8yabrm75YFX9+w8ewa>7N%PI8+pW9(UexX9yZ}_@Ulw)r>2+XDh14X zD$)9<(9EIL46}%1*j`wtuEa5qmuyCwl6DPJkV49@3bn*FD?zL5-I?p9(D-ji0e4tAMsJ6GWYHF|)iQ!2b zXoW<@E;_l>j6s@pbIV;SNq?Aw?mYRr0isak2;Kw^#rf-)jRT>xA591~fxmVioj zQAOM9aFrwSD&0g+4?GDQoXn(?a2Y#%Vt!--Vjw3F3T ztnyOJ94RuBau~|M8~X;lO`10(PBi9N=}yj?w(hJ~;W6NuKN!I`K^`lYXeVk=?Jx|2 zXcQMZGL4O5cmlU&L23kXp<3RQ3MrKMm2MHTmT7`VEfZ5AjgOAEs+lS9+9_i`WRi&zD1i(<)y=(@98!#FE0_u_*jz^x!*N1s)jX>FN#|wzEXNU; z``>>KSA-fWi8Pwb)QF-rSvJm=W_BS#xauz0<;l`@Hl)CA+P#-1b46TRZ)X3HN zfUmBtsWxJ;!&f^105%26olh+LVM;YyNk|xs=zn7W;kF&0IrS{y2&*?`G6;2{&TIQ zlWC%l@{SHV4zS1A7uz3!m3q8m}~KROuL(@E|q^ZO_Z@^gK+ag zPX%mFZasy8A4dwU;44X^%-j2(p+_@1VULC3G1u2?Q;f>h)$;+W?10%m@%QqGIK>b; zh)6v&TC-fKOPnwYkr>?-eKcS_VpKX^WecGM9e~_^ILTx{r57S4f4;8edB| zW*u3ade;Q>B5K(q!0}8vq;3wAQ;PN*8Ei%DLAP)?k2q0E5^3zZH5wkVuAbrYW=tOLowawk%7jGfXtyvsEc z(aDG7_%&Q|Qbk^v4i^Md)PZvF#usxZW81e7uH7y;oob9J*4)qx3RQj{3yIA?STQWi zh%PZxjb=J&Yf*>|4M@V3ra*$>5Xf$;eFqfgkP?t7BSl1+um9G0{6ldpGZV`FCdH$Z z=6sCAX__WRUo4CkzfxEZ-ract?%KP@RCq_urySj)gaCHW%C)TPnUX%VV6{>&mbB18 zhzL-U7$nlY>`s^32PBIWj_8iM4Bd!WJZN{yxrZx^`I@nOa18LEM0#0CeJa(5~zRn5(i<95aZderB)0@k5KY8-J-T@zYgG)VKu49f8H2i>+FT99(Kn#=p0YDO%bQ zPBwrROwqsVPfD{c8I9KWYm;F6yeDVd$$*XGJ z><4}bFB}R^nkZ!usp+fg={^~Sio8UFsD=E}qbqzIs zBT+Rs%rvdGDc2OLhul(Zsz^8Ddt0S zwm_0hUN@EG{U8G3$=}3sjNdKCXN5d%5SF${nyxQcxqg-r(acm-Gko>|^2mpGmKMTg zATiSB{264=h)|%->sZYc-kQTZ)M4mch`*Vv5-scvsmOn?wYY0?kZ8T4bpcmh(>&*o zVYCwAH3A07p+?GQ|unh-U3pag8LS&(I_oC_TC z=}4=Vp0Y?LPW#@9V!(myHylh`B9t!hC{aM_n8&h*Q*!-P4NRh3LMZVYM#{uTBC4{G zg2ZcZ55tDGnikoev{tQ2R9AI4^!Ub4&CtsVl%ZPf(yEZgR-lmu2*fi7?a#sjv2*y~Sb2$t_U~GIlaYd?v+s2uBB`T0&i`Hkx@tkijRM1k(65&+X z%y`ZrQdAk*SEH67K>!_0q?7UbIB3gZDxNV&-*A-d<3L^}m65I~Agz^<{)RY;>~iV| z-SlWUYa)@6G?>fP^;i~erN!ZzN;i6Hm|~ihOpNX4Q_E%m9_2qSF>sA(juhpw2vpJT z=s&DEGKP4QCT55#D)Q!df^kn&<=#3xViZ-Us04sjBwf+TacxEW9tQ97#dk$%7>YKv zzm=sb<3eg;cpgp1sxvKZ3M6@(5Ndpfj#drTbvT`ANZiD-A+;<^WM(5`=swXLC$W9! za2qJv@eHCmO$%K+>E=Iy=S*W4%{aAQXRgHX&+7#?2{J^qIBbzsOB`()#M`2YBH3hd zx!CD_SUYoafZQjCM;c1o5^<`{>pJH1)jZucVXu5=9;_6aR5k#3gt@;AV8JxP;2I2a zR>}-lI7G5ATDq90e=N1vVUz)N_zoMW$P`?VB+!Rhip3Fal|_8f<*Ldz0Oz=Gub%Fc zRVv2=UVLChfo5uhBeh4))5d0!`%jrcPO2<^An`TAKv1Q2>e^^N$PE7g)fRf0kDF5@ z^|K)$5Kj2dj-#G=QoJ@++Yl*N(<$=oboGZcO7w8kS5Gx8it+$g&0WP~Rtnnp(2>nv zB*2b})w1^Rs~^MjS4>kZJ+lB3R&lrfLZj-;sCWD0F-TS3Lv?ab464njfcq;_b= zV8imWUq$}_i3{=Oo0U>qg^0q7228~3Dk(8@K`D@m%IOR??u}h3 z7ajah51dZQDb#D(lCQ|5ifI@$v+oilEG)X-#2cIG%Aqvd&X6&vc@qqluP)P8tOiLL zYN_C5?!W0Xiy!$2^7j}TdeLO;p+lnaCNrO^9$3~&TsD?GB_m7NG?(6e;t4;c7vdN2 zP86|Zg&CsD(|=Eux!XBroEg-*VD+s|6-KD_;8ZCV7P5$#UyJWE9S9M&kXYLHii1r( zH_K2`WBo<6zFmGFRB2!%zm|{~-q-&CiSg$iDnfe2QB4hJs*TP=!J$lNKVp&7m5zMH zB%34yafjsAP)Ihl_aD1~ywTDiP_HFsaHfiUKMug~9BPdt8)>Q|u0;1p3}cPK0`|BA zP9tSxtRAW~zd%bQaG{T^+0r^Z6Ag`k6`oj<8a=@55{4sjzkvJry49UZnhHMoD8`E> zVa6b?%vdzub4ZO_OLtEf^UzygyN4|Z1PU!uv8w>1#-oZXG8#$bhQ7DRh6rL~84Sy| z#>GYKH9QZg6mQh%tsRE};S~3sbFrnub9A+niE1n4o~}8b<;<-e z()RGu=ZrOJ;s9)?jpo_~JuBxN8kuuESjBvh#SRsX!dX>>Vl&YGqQAn5VS9H^}2&$mwz!Zqc}kp_;xIwFvrH|yYE-F$4aQT{Hn}OoSg^xhl_JvPZWof*a>#^0XsZ~Nt zOfbk{O{GZ|Yd2%3ZWeD6)Y6bRMJ&o$4uu}N|JQN+Kzoh{v_uq^^5|(6eZ;s7%=gm%=(xYLUP*RS z-Fcb^T>Ze4LYGM^Fv|QltXPF-kZLgcEG8OOkhq(2Nm`&r7uu_Hem8d7!jaKVFrc8L z6cSZcoL($efocpASVt7b_fw%iNfzSZAcILmq{uaAo|SR@3a6!+{{Rfk(yZSlj!?}; zDlcc1aL6gt9|B6Z(rxhIUpQ@D@=8Y!#)KJahJpy~(+gZjH1WkiMGSO>a*dm-Ax+kPmsxYMCD zU2$)Mj@qiOmEmHS52>C>HN7KA+qI$KF zafz`x{KXdx1tY_+(YJ=g0;*)BMDU|QCL;6Yx@wA<3dYf^4>^e}2B4E`6Yb&`j4CNp zAOuiFk75u@g{2%Zns}+&o<-fEd(K=Dw*LS{_^VD7oXo{omL@82_~~ept~qI>jKw=Q zzUyIq2_62P5`%>}p%jD8Q~aDX@y${Gj?>}O)5748&M`WE`gZ2P!mN+HP)8Md!A9Mre>K#DkdVM;k^sZ6}?K!S$7mlthXL56=o@i zS7FFph~q$aF;CpM*8PtWJ((paBx6dOv(%_KQs)ZjZZV5>QcP<H&CCYiK%N|MW(1>V!-?6CpQeFYr(as0EpOlQ5D04m^*rCyj2<)=AktYwd1U` z^AMqIs_FqOO@Z(A@a>^URGJ8&R;A6EmX8l|VXBfD46$8-xRB~d(^GyLwo{}NMQ#rf z0)!;PV??B;sU{ifL(H>oQV^&IdHTMtG#rsmw80!JCO1g**;gNyV3S8RbvKymEX9)# zjluX1Cv`(rJ#I)z!h%etRSRYMYJ`|=XiJjBd!UwXU1J)m6m)}6*gh>^g5{iAzAAOA zSSn^ghsZ8%QL#^dX*U+*j{pc2cJV~A2J7YFs9GtG!24K)746AVvQRUQtiAX&n%I#PTN4YhJ^C^ zh$bmIktr0E%+m<4h^T3f_+eI(8D(wlwIe5W`y1cc#dhb#CX=jqaiYCLivIvF!@how zr77y;mbRWq(?)e_sUL2Z)NbLbfd-3}vYM;vT2`boZriZbpnI@mAPsVF-;X7@rk_b7 zhW?ECM=N1b&rGhKbz}L2>ci&c0R8+$nJj~aFUuMxJn2Qz*MkkjG5kRz0jX=MA~FI# z+te+NmLI!rCU+EoDOJE4j8Ng}wX(JilxEKuk%}j&#nCY(n!|Y#igZ>XPNi6Y1^e+8 z_)%O_nP!j)G*k1QS-`Md&7Nv9&1*GAXRgFCTsQ ztD`X8zhapl*C#@j9Nmjz0pUt>7fzK9s)g!_aoispqBw|^XQ@RXNR1Ilwy+mc1XR4qL%M75Ok@zWs#&2S{J zJFG2XeLfs#TnQDR2{F@2?x0d)7zI59SdJYG7G%__lAuUd=H0pG3QogH-)&%0m!Yz> zJx{^ql))O}G1Sl!BTxd(PU7d`axcx^pV-%|Q{%+c?x)}_T^==p$6pg5k>L4|w!YA9 zW2yS@#x387CY@Ehss$G>PFZ4HR~FA1dL8CJr8fX^A3C*@I`tDn zXQZl}9*aHa$|?xaD5cDmRFG4{8pIpOq>QNnO8_;n9?*Ce-j$FW)zLysg{&3_17H8p z=lFnBnykIjyhWh8(__hn$1)M_BjHt#bAN8Z%y`{Y%j%7h^A(UA!hdF;Kar{l>fQxJ zI+o+IaN$fx}l#)&!a{B=b;Vv(m*P zvAYV2sEvvn3+@A6ZvDw9BCVIRA!CgL^pZ~a-9$1F$kiJRZK|)9#1%I0#cD8`F9uv9 zjYsvOPM-ARABvgdto~swE;5fxxHNSiB#424@j}}0xlLxc>)bTRguvdoKdwHZb8+t0`MM$BWtGVYNgVArMy1Y84%Bspa zhYrW+=Tckrm~III$Dy`?fW5TgWuqY8I0)K4VwPMihLJ-)Wa>m1t^x=Gi~#3<7j zgLxM78xQ%w4ZVTEw-L8(3W_xEglan}TZUuPbvve+_Z|LYQAq|nhtwQ3sH5|vEgl6+ z0-+#i+kqnfA5R)mJGT%Il~lS5Wc5`}bQ)TmQaIMSCXws$%1C3{8{B26+h!)>MdN;->& zQMyNm^wJu<0)h#nM^P}Ws)umh?<@Pp#2q_v9hH#$z&$jhF}Xd_>Z-!Q^L(=AY^evE z9Z#O}RMITNaSVm#p2c`L9hYzUpvi4)1Twa<+TgV`$ zs&$DP{s+I)#o2NJc%F()bAkt56TX;YpD~VMHI(0wpQQNQuw+al52mG-nxUwNUPUP6&H4`&H5`GtKA zHJpOdk&n?wR@E6qlIp$O1!k=&gniA#4X_Fw}c$HOq#>WnU9V!_Y+=~y5gB`k- zw4ZPssZ6^ONL&NE28lKii6{A?nd#XIVYOI_*@z{hW^}jHW5eVm_mon%KWB!)Lgo!s zhE!#mT3XtP_f*44n?!RmIC&QFdJVu@ihWhChoolFa{u@zCi20l5jx$L( zMPTh12HTaiU39k}LS)i%A$0G}r2yrGBZ9Mgzk_>$F9(8naHPb4bp=WM+#VVN*JBAtxcpE6cOdjdMM?h z>INx>Bh%8-R%I+34XGcdu35x_K&#-3BBL~y($*UBYlso1X)+f$iUN9>)Z7m%M#+uK z9ac9{O(S4gYKZx2kU{oB08Yq}ynB=FB%W2fRlIyZZ7uxD8Ady4tMKi@f6kvnD? z0&$#Q2BgFB90L%n-pfMrPdzwT;~E9qbzf)G!z}Oytj+HAKJD#F?--r51 z{#DehLoGIT!Fq*@Q{{ZlX=(yv6tTV^Q&kL*Jl9r*T9EFHk?%I(Nz;LBosZ6HY!C`W z`{?fRz`{WyW{`QC1i-yX(^uno1UP;VH7nEB;@BKTC#ja2NF$5=F=>I4H;ov|g%-#~ z@7!?B4ldZjy|k5WCFII#usY?_<>}@LS5;3+(_yu>qFP$~QYMaA!phNYc+c4&t;O^r z%rxMqExPXrnj*MCK*oz61n@_haf3BTqDi8sk{RX)%ie}vO}pIbe~%Abz)^Y>3W%vy zm3WN!r7)(&1nfzHjlI-BEKa?F9B;0@DhF;9uBfc1#Io)yK|NZ?n0<6mRZJ`y!NY+h zf54?ZBSDphT7 znq{`*<864k!zPQ_m@`PKiD8Eio|z!?_d8J1%)mOO$R@<=pyGt6(+?6hP?gd;@kNv( zk>mu@O;lfheXCI`Xg!+o9qK_<80AhY*-C7jDroSjXNFQLF}m3+YT;lDDzwkAY2rn% z#vl{rPC79&wwK*4f;@Al*gjH{Q4&?nK48Qu11{=kfX>mIU$V$oQ^dE!_LENK>e85? zE{$um7JHWzti;n3d_q{Tnp&z=0ZaKPBq|e233q5aTZ`F7l!&IToD0T=UY6HGg;Z3~ zSJeYmjnS?u@wLH6hsho9>~eTXn;@u2qr8d8BvK=(@w?_)nyfu9TX(>ZmSW^Sl$69Wr9OrK^*jOQ`JX()ag$pGO;WU?ZtrlxM5^~ ziPC5);)>%{02#^}S_OgTQqeQP|8RiIxUAC z%o)_)nonl=3)E;N#4|)$r#ihIYPXw$M$=Xzd#LhA4MM~={_nkO_u|&A^f!etw}RAY z(fWT_F>21M80vmbo?N?4ZO2m4;zGcK;CGvzAj}2{^QTw}lN}T%RL37<(;aEcn;b2hOMc=5Z!8)eCj2 z7J{2T;Ssx-r!okq-(n?=;Xd-O_;lCf$vVjgK{N@vGIrAAp&6eg;CZh&E@_ffp`Q(+ zrKI^;RwB=M69v#*Uf z@ufdV>Lr7s-C@HfrYLGMbUD_aefOCtv5HvFm+&#vvEn<%&*lLeCOy<-*a~3D*+Q-- z44Ko=Mh%!|k)n^Mn4(a`Sf6~)9>xbZGBDpKH% z^RM$3rZiQG#41NkPSi3jyhAU#ZS3LOd2)5?qzk;#n5$j%`aqf694rqzb2Q zn~uPKyKpOT#*_gY1qfPyQ_E1;XlUqGaHR}$D^^Dj&PbGutO3+0CBD0N;U;L`h5(~m zCCY)K3F_Z4;PrVUskFFdN6BLt<~3bKT-1evG3L@S26FMVA+#pq_yvV$Qy99}G`_^+-W)jrnT}eNUQAa`ZJc4s@d#IIl?YCTQ*k@1&mx9dr1R{4Zbw#bU?1@dbLN1<(zW^jK^0~iA@9os;rYF zX&qc`Aw~9In>MEdR&CHsQ5DX(on}wY8KR38`KqIhQF%F9s|h5_yXFHR9f%u;yhn!& z8E7rJ=-X9&(3uoC^ou{^wUr$_wH&ymRtb!z8#1d}My8m6_mf*~+)e%*EWBYU1nino zZuybtR$tVfv}H`MQC8)imS1PtSROG-bNHwVLa4ZY6_K3d)RA0Us+@Q94w_%NZ(c zV_|b*2qWp>`4(s?Awp;+-l;1PX#W7^E~ruZn98!@Ii@T!uc(!Dj}B?c^(7GEG;m16 z<{&>wudSUC%zZA*D~;16wf#TF0?}Yt zp}pyw8#R+iqw!w2zwo@2-oW2 zW&1LrOKlwR5!Xi756+dC*G_QiFXVAk(`EcpI56**Tg@d^eJi`Xr^T3|3wv8n4hP=0 z(BzIHjnMx9?BLKFpK;l+x||MZ#ifNLqlmE^3Z&8kYY;JX62K0 zB$26_7noHn)(hsKvjOnaiVI{@8s?EnF{p0(y7+r5B2wC&r9!Z4)e<1lDh>Fdib3r|5DUSxCCRYs@xM%mc7qckLRS1(CV zL5t(n@W`~&$%|mvZ8NUblto)m&iZ(Jiav$nTeM2zsc!L#OyJ!+qRE)XL&DKsjyWo7 zr*SpfQFx@7wf>R_`gp5ep*2!K5GVuA8JbEg&6g|a(Wzpph14`A!9!ESB9E_bywl8u z2%}uF(iMd>;W^?=dof|(F&LA`ro}MnE=_=3Hm0Yy!%ikewv^J_>ysGqqu138Qog?) z64leGlAfI5^a7azrIeHLzJ&3s6oE8Za&;OhokEF};T2GTL^4w_1OQIiqdMQihYTle z6}$vdk*3En8f-3D@S4del2~@sM{%`+d-mG?)7Xw9&w+^dSo1gSTfMOEdx77yh~uvo8w@Aq;0<_rue zC9|_M8sqt!02$VFiUA#3I>|hdF;c;X#3tWQA7zykgTkA2;iyr==tY0cRp%@(51=y| zoG4UQ%?7>>EON33a>zcG+}D8Bo2xgaR-K~c!f=Hqk^SSOYX2NSp~|Qc!Bxx zv?wcOX+c7PY+gue@vQM#6)R1G&{1J8j7bz`aZkP~s4T!(-0UX)&S}Ajt+zPE8{fm; zZzC<|flXZ&B}X=7jHJ|TN)Yr2ibd>f0Jy)mfW7nn4=$T-eA(`77nDr@M~21>Y`LOWuTHnQ}=pjYey*d4H4&IV4t< zf-lc+Ko_;{J?{&Ad2GQ70E$3$zto*PX}coK5d^+eX7^spkb(vnj}%x5-QC`YQrGut|@}UjU^pj1X0t|(JYEQ#g>W~m5PgN zsnq*8819L15-8v=!4pLjr}<`R>jhNI4K({|Vlgn$qL#z8_4aV(*Kmq2?!<_zKk42p zSA+Dfry0Yhp_dh;smxU~?JKz_h9#B&`|Y=JW3_tIBLYD+ zHZzQ374f)N3wEoUPkZ7tzqZ_R(IFUhRW6oRWaCAbtT|Sr2FuhGv9rfbB2-q=JF9IB zEhsB}biRXz){aWzkX$w40+imVG0Zl*racR&rky4+WlSmRT08sF)x^`eZ-^{M)yA@r zqWgf;m#H1fNTM5rViSs*aUA;(n4hEv<6+yz=Ymp!G)xuIM_UQU@spIP)@jq_DR62b zK^%5gMMyy{?*8$02L0{A7g-wc>7xeTI%j~Uyp@fp#ql+17Ga4;4DODOY+AsbKC{Q( zX8~Ies2@6e>)D!TKkIES33uO!e&i1P`R4Xm4!4y%) zV{it%MDs)_)!A@q6+b&y(c;-+x_A+M#g3sRh%L29%NAkYWtMn8lkAfsZ;ta8;;*uu-M-$I~o-IMn5Sq30xQCnM!q zXR4uxW2~8iw8qdh6wF8~5c5fvQJ}Wf_pf9*i|I;AM$=2InNpRijYnI0*MxNE2Wpz= z;jPRwL}I{l>{eJQsp1+9srDjE_U^||Y2bN=ORB?V9v4!bv`Fy2t>SZx$Bg1K&zPSZ zg05pzO}V9ybrj1R006XU>>2^X#_Xa7$}f85TWY?ubor+}=16gcqL&Y*oogyE=cu;Q z)Y2R67be$WHSyq?hS1w_L?z`au8Z(L$8ieYqWXfGa`J-~Rf=f~i-u;!1%mqt@5uiE zv`||N$4}!&`>P8MgU-sZ-^DKumGW;&F%^ewLl%~fX@<9zXeyXq{{TVZcI%`3q?7$0 zn5FrHfUpueepRl1Nw25GdYOo}W3DSfhf&J&2}hU|EA3E$?R|WH9Fv|#mV|AfOKy_k zos9IJ>@Ho*%SHi9kSeVvbw6fVgQGo?agRav@HSFJc2 zy$?@aOX$C;yrG=(PI8hFpCzS=Oh+fw7}g5-44z4>qjRFmx;xnYi}>J*LNyj=GBj~6Ymss|cQ95fzQ zViw1woy%IPN7-hzqb+f#vra5ZL{eQu5@>$u1Qit+X`VTb-Y@85;PWPJz$cROESQ=)Jj1d_C?~?^{{X{D zmmQNCGP7;5tgKLlTz##5oyZ(dc8w=jO)$#I01A2PPfn<3#B#1jk4#4DaRBlp)on%5o-3F*kRPvl2JzXE~+WlbDh5pIAG}GOLEsd zW{`E$Q{>FsMKxLSaQsFZ`nV)g95YLW)l#o-2L(vx*hyMQ6sG-pPCF{Vs1=K{3t^8Fw1pdt191UwTRQd z7Bay}1BE4h;Rc5MD-w>U4lqLDrk`>kCwkaqY5C-31k+ggw)%GuDBdQjCSc*CNhneiDBV5bcQD!BLL z3e2j)-XIb8aS*mMg(&aA7|;=tbL|}1_f+GavN~95Y4D>IRW7I{jwtZ~V|x$Y98-60 zttcXyw{QZgKA(n;4E0!dRPjoh$m=K@GtkXQX&D(}65)#&LJ$iO6zRZD`!ZBf1wB1v zbl*D!6w*AwN%tC4?vvtfcwp)#CXh6!27?sA@jPb~#Hn!sYDJPq`Icftg__})=mz)p z@lLSNoX-b9>MJpERoHZHI=bA?;S-Lc=n(AYi$acB6Yk_XuJr{7Ex-T}T zRXSs}b@dTu3fZvtf?5=zqLpJC@8tPZ?B43zUgPQFVWa_9SU8$mWh_=4CK?5*rt-`X zJ!ZxN>;$Y-f#Jle$7Lu<2@y+tj@h%RxL#<%a&+Ob2gC*yE*~tS7<}58cPn1aa#2mk zj~TytyLc+-r>t$9xk9vXsM#yfKdbDcnJ~IMIn{@gaM~XZ zC4YPDTuC2~;Z|>Uu9CUo>G;u)#yu{2hL(d5YPj%0Q3Uc=%P_8;qulkcP(_73_47M{ z!uGS9VoZGLVzTGbApEGB`lZj+6<4T;T(#Zv_qBY@OZ$t5dMpr&<`%t(PG zA7Q_K2y&*wlCYum;0^5OFL+F zYNU#PQ)vc*{1SqaqY#cGSR-?_P@x1n`QuL?4R~tm_8LN(Fm!n1QstaJon=`H(Nn_Z zTGqS+LwjH7;u74Rx_42Cu31Aot`nIsc~Zs-w}OtiU47(9gK6Hwn_E(vX%9lGPgC() zoXgXWotR~kt}MTS;rL-$9I%2z2x1g?4Szl+wN95+OV+(e6zS>Wnp{5s%$1M2)e2~x zMz$tB3BPZnmA?eIk;1oXASmsjM=Z--7F58bSpz*q4I@O!xLa*H0ry*tx%V1rnTmF* ztFFZ`>{^~$xfHAt$s}U+tUic@kFQ9%z*Xz{EbO8Q!?9zv8fkxS>vU>52?Cieo(uhqp@ zt|W;YX+5K4C`}(Ovt(>T4XCWD`C}Zj%|Dhl?YI(#vivpez}>5*R3o`Yk_|Lve7j$S zW&A4`#3nRUiBpG4YGec=gNf6|$6MQIe%x;1aHyvnM}h?zdA&R2?CFKlS7&-}n99pj zEmjqWVX`!Jc%-q;r(|-*K}dbuNg(!>U3Cas%oLH~+f_DUY8ti*!PZW((e$p92&JOK z>8kOmLSR@10ZwCrhYP0=xQ5Xti4jbIMyVtA!qpG_BWC%5bWH>NQqq%@q|n zmlwvH6061Jn-Z%sJ6~%kK%gsFDvh9N!D9`j34k_H2Y6SB<3ksw>L znzJv&-lqzv>3>bB+3!^rWO<~A#3JEUiss)~*W<$7-%PqkRC~oNx>P23R;zTlahn~+ z5IJX(o}hx{FhA*wv}i|Q+>^+JgFw<{MmlH-#<1*GixsXz8#Fb_5<;L8xHa_lXn45< z5lkpRshLAKX559Du*}VYPc|Qzu$`4yb!{KJ<+M^0ds@Xx=*mTpW1-_$7R|biD#RLc z+U00iP}(Z;x&`VpBYLsPn7&BPcytFdVf5wm23nNrRqg(nL|flw3_&V2jOcyR4X>UXpcBG2sbMfMN7FjWuJW z)OE15yI458saX+NcDN)Bcvy2bg0ZE_v2rLn#l1H58w{t!CdTS1A*59K$)^Ho6$Elw z)Ol#e;F5cG;^uR0BP$`K+Q-^Obvecr;syBr@ zmc%e4xZ(2)?-8mZil0G3^qNd!6sBBRf=D$H!3vw%ZEp4)Qk|5WQ8X=diyM}XlBSTo z+8Wx3&;e_aCGLH__?GRt6>C6b4m2ob?Bj~dobVbbDh}wY-ePQ}lp`~P`EdwsI%bwS zV8t2EnP<6cvduObm!W(zvFa;v9L0@F%OurRG2(SCxUgpKPNPqwmAXfcn_z(_jVbWX zrY;|VR$(GK`70~_W*VuPT2Fd%%p5m>9#|xH<4U#wgI7y{<5lgGuuNKfP3r0>znfvw zQEkP?nitGjD2!2v%8{-1n|Rxb?!<@`=3RB6&lLdON|Q0g1`k1)aPvi1fz#Df$2yC} zH9wHzA%5GE*W>nV0f^&TySpnMRA#W=rs6oJ8&yoT1V>3YYKbl`%1^pI<9id|ly#JY zN!oi@gGj8$Rb7ZuVs*4N2}@A$JXHh>Uvzh2+p`UO_t%dyLB^YO7^T)#&Qz52(??rc zYkYu-9amA=&X|@uffuN77i(OkmC0V3KC8fAE~6z+WtN;jmhNHja}q;j+At zd+>(-Tet=9s9iV+-iC_wYNNcB(2}h@YyZ@4{6(d&!!mwPtf7Tu#A3zXs+fX5NXdfY zD7Okfd*R3zb_i9O)eA;*?gYT4>VkE z-FqI~kkxXgLDNB`TldNmV}%UZAK}ZDF$to0a}8rVstxNbD|QysSkG;ERCk%pk^Xm!Cq3(Ta@zs%=4)MZ9+cR<(Ot*#Tp!;GtXT~F@`ysq&c{{Ygh{gyz$A9w3Zcz+76nR&2JTh$DG zrgugX!SY1z?Q%+SI`^e%5vSk!R@1uDcKg3t5McZ+vLupJ`5jNpk^ag7^A4ah^J(_WS<; zO4+bT7@f4E!aoY1O%lSPeGGo! zg9mLKoEM^44Vsa$so{b*5sxxGyOh|HK!2x%Mbe=$Mp_6vYc?g&47Q6bapNeYGb;J9 zGTfUR`;rjX_;JLQ1AwaP)G;(cb5G%K&4Qm)%q2T^Qnnw4DUB>`W)a+X)N-HNN2deN zvXdOKzv8C6Kk!!c`qEFcHP@{~E+$8U3^8`@JDExH6zOd($JM-dIDVgnHk`el17&io z{1iF@6p1soDjQ%Bse*x(7#oh!4-0Y8yf1V6s=v#SMl~Hj1%80V0~m9DCs9!!mSK)a zu=vBUB-}c}Y;CU_R`T3z=iyfVSlK;QhCjj6qSXHYp#HJqX-OJ+Vi{ziVX<{k7v=3> zJ8_k76~y!SQk3P4CY`Xa!c(I7OcfEXYQRC;5&mRfkUT#aWC`B_cykWMg2<9WyZ=Cf&GSb-ivSPzOHBFtEr_=#pcfIuj)P zIyyf~O+h9b)J)Md^F?(z6!yA=5loUpFx4{MU+A zFfgyrS5n9TZs9}I*bOwcyht~NNf-`&l<3NWjFax5i#YmA=%!DO3Td+*W5%jH)RLbr z)K=3NCum(|+aii^L}aMFj<(Z^n9ZG8n1Nn*E>6I9P~(!id0CG`^CklY1S&A#_?Js2X=_b;D5muj(oRMGv(!n5Ly2NI)ohDZUp`=(j#=t8 zzWCiKbl3?19}lC2?eAmA@PPxKsxVIOH0TSN=gy+T=@+CRM!(feN}dIGr1`3voH|fn zZlD7~)*l``jp}_ztDdT5TeQd#J2~m3-Ye;kqu4D*A2tJtSK(Nq6CCvzeAKba3YGgP zY3UT*fU)r-n^yEbp$DIJI?nGkJ9+lhY-U_7AXd4#qkLcIK-l=mIw0KMz4Dq z2J5x_d^zT~t>9qc&y`W_+h?EOLr>wc(d@aBdZX1upc9C(3QRb|Bb~0I391;evWqUZ z`cD<+IkK)BMA3Kh)Z3G%8KWKeoMFj^WWJmK049-5Rc=2V)$(HO^2IGL@`~k>H1fsJ zk`!<3FU4EF!HI3{5!HmM6k;?X2jj)Up>RDO{yN&Hv-_E7pr-nDcSG+DdUl{ z49xm|v?|T`aCFL8X^m}VSe{frC>d$gvX(Z!)Vb}g_|V>agp5bO^rsF=$vb)W)GQm( zCPC?rIfG_gwV3fd7Z#(cjVUo~E*e8LQcC-DbW82E!vmog2Tmcq-gUf<3lfvhMJ}+( z+ig;lifGHDPy*nD4m=+aeuQ{0KZ6vAhni z5sn=2pmVuW5TFR59}fIEx(SwHkVB8-B02WUTpF?;GC(dhB>*PFO*G?|8LRRICuYGo z(2yDjE_As{_qeDpWnjgH1KJ3$C+Qw2*kyjoE}R!?K53 z{{TqYZw^RX1Tmli&Rz6 z%M`TrD@3ecV=r(J-(Ta;CgDlMSBkX=qQ6`CSbBeKR(w!W;?-3VEOAoIDkF+bsD%Jw zDn7T=oAB^&1;SDU;m=hUxs|q6B;!HeIrwJu#cKpK)YWh>1Ik*dqGq*=7QA%qbU%L+ zIlXrwPzOHBG;1NZ(I=mMJ5c@@9Vet!c-Jt((vLBurKyG`GdFf0qaP0rFK>7sT6{;J zWfq*Ngr5kdRuA}Xbk7BnSt;r9p-{f-ViVU=w8XunYabxk`wjW!XAVXRrq!1;MAmqJ z4UDOTGqzOCIOYLQT`N>pVUW~9&`l$f?CcC+?j-B+`go}s+lwA96qOlkX%H#KoAB?; z&{P>4H)B@?gtnfH2Dl&wQ4qKn@#8DboTm|&v@zpY>3DIt*uEo~5`EHvT=WiNE}H_#9xyyj$S2vw z4d*Y!$3Dukvc^u@XQTWxa#4{hW`?Y~AoHPs;mBncHVf_^-N-y)-Qjzm-A=caH8>i1 zru;K{aI)S;Z;+S)JvB@*$mD^rg2pw{#QZpu`$==K4}a-T{{SXtF+T6slvsD+jnMY2 z6)l8S_EdUEo||Kh_PE~##qaIoPH$z>a3h~(S-gdka6J2IRTtr<>Eu$+ht^>Avdb){ zN^?%o2&0V};>5;DBgFhTm-|}yICJi+41ot`&U)*y_;Pd@ERfAdT#!mz$-PB5YYSfA zp$5m}#OHgR1atDGh~4(~aObYM!}xM^8~qo`r^KnnISorJRgs5+L3`K9ku z;9-wGRO>klMNoP7(~c+jar%B9U31};m32rACQL%LL1Gkp5Nbz$Q5(^CQ-{m&s=1Y0 z&Lac`>W@BveobD~v7pQCtd z>0^dt5}$U=ibj_t@ao%n+XKWXsr-nm0BFK~896T(=}kXbvQ(_UGl*j}IJH$se=r!~ zqmBYpSbdV(_u@U`y-VQ=PRjOQW>`^4+h70H&G?Z~32-c{MHS$dw-ZQk`qjSOaGXRa z_z+KV;twEA+mUvm!%xgq-Gu494$8nrz1riIUnU*E+Ap-=LHazMrLe z+LTMI{{S%t9^jjk;Qk|vt#>xz0D~UUL^;m(Tik)95gkUS(0(@Fo$*MfiY}VxI+urP z%>bvv&;rCN-}Ii{IH6moa5_Drh>mdA0ZIH*@sjl6RZ|>Qy)({G%Ex?OdSTAMk9OdP z>^SRtvv2{#N0_G0Y~Mv=to&j+6Nb^xi#|fm2MVIIRZ5W1mQ;HnJ7a5;^l`*)%c?K{ z_SF}gwvjYDbTjd1=r>ns=WMfKDcKM3era@7@9L~=_=t$3O`pk zB?HMB*Qz&t&olZ@SxBOhf+{{V-@^v~ha{P4C=z>0bUw*LU}C*?-!zt!y(ujWjF z$Jt!u{Biv=&r2Lp^tU_CRhC6xBM(hQiT(coqn10Taxuf&E6L4Ro<7Qt7vrtzk_i%< z5a}*?6T}6QiX1k;0c&oNyg1XFp?4TZv{lucGbxXSIKlYk`dqD)tbG{IRVfT&wlOoa*d>WMQQxmrK+<@_~Uw8QtbysGulW=riz}WaKet=fh0Y}hi+-@ z(7IB5Bzr|&jOCFsJ=B24e;59RW0cj@xHm*|gnLlc86IpotkPTtb#_1Du^d45<36D} zvGWvRZ@h_3BQW2^>n71w;dr0TE5|9J$)DCbh>`KimAH|iNDl9pi0IOGC*51?!rQIXTMhuF z&$5hdv!uG&(wO$pE7!kOSp%TBjt^6xrmxN!!yUBKuo<;v&T>|ygMdMlPRFW@Y<+qaf#t}tcto>_JvscTg$l~H{o7$ma4=hB~vxFZ-v@a zQZ`VP_?FO9;<-0~Q$omUMPUg^Di-Ezf@^!3WXtVi%L8ZPE z_@w0OdYPk6kmEAaQ^ac~hKj0zRuah; zKhjLo906=p)?v=uI{=DLw0n6)?t0h9;Zzy&5_VUx{{Y2rp}3kz&C;CBO$|Qzt^WJl za8qz^yX_ICo;+<^j^ak&g*e{wB=DztkHu@DIC!k4T#cJ4RafM(iZ)C+qLwl} z?ZrRYcSs^cyp0tTPw{ zL!WXTO#)%_RL0Dv7g~~D87wtM@$7ADo#j>vyab^_e8mx8IBkq5V@ke=ek=VD>W&{r z{YvN#V8P(3sHmf)!?B9|G*2wlgb8E;NxyO1mcHG^qZJ%|DW)$%fzw8MtJYo#Qj$qg z(R^`s+2WFlzJZv6Z}xmOzX%s^pv2LmR_Z%&raIqPaba@Bh)2>)$%o*ut4UuyRc;>~ z;4O(&Lvd}U`tkn&%YX!&O=&jjAk7vW`S{iPe#yA>*+UTM)^5bH5d;{5;#e%0NsLE4 zVUX_JZo^yf?VZ(e*5+f`MQ-LH3W6yKH{)&T;bo?Hx)+`vI*W;2s_=g?${p8ISoRm= z$lTXp$@o)8JV7xSR|>z!8`J$HQ>yeQI;0y&MW~+&Vm6Rin>VoWc8QEb|wC>#27q*XX&~Ll6t>Rx#JUp zy&j^PU!KANvNx8+h3#*6TaSNb9Xx&%kNL6&+Qo?eHJt&ftXga@)9!VojzAhP^|&j! zdz<%b0n44#bR18@wlgHDRP#ajvGne%2gPxL(7fXoABEGyh*!ih3=9DcM6V2CMb5jU zKX(~cLh48bTYRZNxdccXDJg{hH60Jd9KIdUTO*`-8@k-rT!>VAD$Hl-OyN=6@uR}) zYicWD=w2>xnn3h(&_jq&w5wFde)Vg8n;zULUf{e>-|(YEXY2%EpN(;s@vZ5V(hAQ` znUm%v4S5p~!*;MuEoS)k<SM3Mx3!dR z*SC)xPT(yjLcSE)-ekl@XQcdPI#E|6(^UF@&5}=1DtTl1h8w!fLW`cj_6L^!#5yt6 z@Tv^$3gPjme1GwN>HY;tOII(Z49P4tCDsEDF@(E-jOb0TrmM$Mx~?cjtbHp=%$o;g zAn>oo%cJxV4RMD==wE4_7LmQPYKFQP&FQ+!W$9UpZKFVQR!qG7i9(1gi z@m=W_FNQ%}-4D#-hY;H|ZyAO|wXPI`rrKLj4}K+ka$Y+~_KI58e%fH;?4YWv@m%TU z4P^C{-4e_-5ka~%uXm-VX%se!R!wy6&7*MMnbq*8m%NQ}9~z5|ekYg>RUw|Eqj=Re z4OtS+4N;Pf<_O~VWxwv*r+#}m%a?3~g;GW{6uz=WfB)8z_=m`&2kAnhumcl~W)4Mz zt`&;0`^RoUyR;H+75*>GRN0yT0CG>C$kx04X2Fd4=M$@{l$VYaq)Ku2O^=$SY20qN zB+Dg0j*~$W)_|3Y~1{C}0Cv7LF^2Kvi zMpBqT1{JxR<<66=icvup@Emyfg&GU6Cz9B9^_q9Y_@Uwh0KKK1XXooDWM6w} zK2@~SUL#)W&++^!?dJ&t?W(cseA#=fIpZkj919}N)4Dk%u1re|tE*b`QCU>2P|_h) zU8D48L&05wRKrCi%?IxsOYQ>^6cknAbqK#J1b0IzgU?^K7r-sOzC2ckDvD~Ia)w%Z zjDD()o)LeM#NI_9+hkaLvw|(+SwQ1=4#3-6Ww2H-r+mSdW5MEzA1hFSq$fgbmbSh1 z9P>_U#+-G!MPV2_3WsHcls7Dl32m%bOMO=2r6@%uN-@HhtCeXgDom175$2(d7$x?x zxw*Ezh4|5U^wXiKH9sL`2+m-}DdvI{jtUm?p0I7&8gMRwy`{C~Tyw)(4N0d($qXbh zI;yvr-di&U1h0T2mG7{teq4>T_mwiV3yb0~P8B5iC?qb;`{s5}pxhfCGV`7sDMKg$ zMrcjMGFBCbQ6x}OQdCqtu?Jx#fcLlD5q(dG5eJk-I|;#qlzFbk&RgE+T@d1*(&LBNeSad*Ov*lL=C2@ml14# zFktzYJ>n)@$BbrNew1QZooH!fo=Tc3c0{@C4(kEf4%`!@ZYIDYsP4HM^09%8S#iAu2BvY2?+j)FP6nXuPaN?eOF7 ztOK@~Z1{TUR~Zi$^P{SfVyuMuX(L8du(9mGY7U%0E(oQa)}hx+Oedtc+hwdT8H#_D zp~tCYuLzr8bcriM+BexORGub&^i4l+Y(h;ZCCW7!erzJ9nlW2YBbuG%Dg>Wm;IQrO z<HAOYmR%`fOL7HfB+~X9qCYFY5BPymCW*b&TVN)YIHU7$-2gi}_{{RU}BW(Pr zOS>TWrjK9Z6lJQ)89D=b;D)kECje~({G8~cUlC>_h__wRm(@Sf`HFiqg4hG5wfXfI zf>Bae)4c@>nCq!gyrfXOW!u=5_L6RSCs{g3+s1;gq)sA=js=urn-;3Y)&`Dw;;*Bq zM+ahu!x?*gPj9D&OMk-@kg^DxR`t6mQc`A$Ey}c%#ubK@WFT*F5rMbH=asQ^ka4P9 zvxij%d3!58CR4;FkOq=Pns<^m4YurDTn$HUcw(n~UR0G0z>`e5-vPy^t*eU+rAAt% zbZI~e!b|AF-$yRe#N$o4)a<0@L#@u8J;xI><=lRw0M1!zT6)|U8laS;M%#kzVl-uO zb!9pcq2{lcY4*w%B_^wE^4nNaOd8m)p&ebxKCe1im~uZ;upB+J6+{9I<(22!Bd83% zTGr7Sdu(C|BUCyYuDpjYGWW8#f}1BtJryN1^LOm&Tm_DBqH&Am3|rAwCxu}6PD5Pf zhDV9lROGzp0(EMcv#j4XTbQ{Rlmxe9^?$`7(linOUSMj<^>=ZqSf zT8i9@1yq${5^GYt1dDxvB&vHz*M+Bdf4@HJGIKZt$Ve1kv(K#lreX5cQm$1sbl9TL zh03j38GNdgF&*AwA9xK^fyLJQrh;c#pGwi*5QM=%_t7oR?S|u6qhs@7Lkz2)o+?$N zNetFh2J9Nk-(5U7F12U7OcOL0y>K|aKvF{{(9>dg-Wwazint(JvSS_5Rb7F%!ocxU ziXjG&2-Qkl#Xz{NMQu7zM;FV&kgCK+fFHQNh|5d8o4N zZj1}tZ_Uds?c#33?%{f_Cr??WZ8AtybWtkl8NzT#Gc0(7P6RQWK^*EGgo>nV;%~!i zvaS@4&9DiYu=-qy0%a^xK}4(bP~jjL{A7&Ru9o)g2ZW2bl?pU!-Xzs@;MsaiL#tWh zga%PXP-Jg+`~XM6A{~a4M2kkJ4G!Hj%U*sTjZ+E%P>^C$sdihNluHtPd!8k^c!DC7 zTcZk4;#nS&OkOlNTx%;uB8CIud;KEb9NHh6s+k-qr!M7Mrfg1-qstuyOz}Y*Uuvr& zxgdQfUQ*@gHM@4JyeBSI8j0k16`dT2B$6;L>U7rM4l-XPV@u0APfZOtwnAF$jg;!D zXg^P1Jz7I0h(Dv2d0Xx$h*0^~W1_qmR*-sVn`PX+PhHebsMAA+2xY=vIMP^yU5s%6 zNgc1L;qn|IwBtnupjb^ zgvk|^i3EGBZS-lznRx3nuvL_g04A)D@Pf)1o?FWPpw&ZC$y1pyhKXv${LlB(6pd>h z;dLJ#26wgar8WmeD#@83s|x?uoA`tvY`4<`A_tfGqB_nm{{T$&bgP6R@r&?ne0?clkEq|mA+>mXZfkEe+6j!sh1BuW! zTaJR5iDhv^Qjn!6Pa7BYpjK@(;A(mn0L{%8I-Zmg>^>Ng!7{;1f z2sT!--vdi6Wm$aTrjGoU*PI`0Y%G3rOKu z{FoB=w&1op`1ayvA6|iuG^NH9#)G^c1B(d7u&RZGu#U0>c+ z#8AnJ(^I6jqF0o(o_yY6*Gm!sy~x(wLXg*NMyaL6VDonE-MbH)x3v3*lwI76Yu(TUP+^XAw;IR4 zo8p3&*gg>7BCWf5GR71&_gdoT!-|@_34uvVDmcWm-AGm zR^?RR{X>Hm%sAe_)H2~Tl(NknL4<8~n2KDX1o5K=Z3@p&qZQQ5=|hpQx~MS7BCpNU zLr+VD;Lw=TDoSY>!5cC!WE%)XA83pA?ns7|>ZJX&XqOV$F}8@MXG&^wG+2f^m{IWz zO1UJKS?bF(w4{<xwuPBQg>OfzO*#$pXN6`Dn5 zC!V2-#|{%j@c3!9i&*g7U5yI94Of>qzM~nWa-~av0D78lxKAk;Z?L4gHl|D z+Ryqo=wB(mSHN{Cnx_q&eWT>eU(;B^nAHMdZtoMz)0;#vt&Ex=g>i+;2<|(Yi%PAwL%0h9c?9Z35$rfSpd+>mMC*3QO0mALn-32VHlPj zIjh3)Dp?s_cM!Wx>^703DbS4%3U5${P*SlV(XFeBK?+HND(CuTjby)684<9|M%3BM z1&TU6)0S$;l`j|!m2|#lWZ1E zk*ZbV2_q>*2W_mZ3tLS%a@EEZfHq3Hs}E0dNAgU?gW>e`Tc?&9il(TR#JaR{1{&$E zmgSy&6w@rSQlKfvC}23XbUEUtYCy)ID&dm&@A-oYsqTI}X~)3QCY^1)q>4Kpg8F4o zmvd)Suo;m=X@*zh^o-?$DlIA!4&kr7o*X34?+Tkq8)Rf4R zkdhCSE2$(+y^m(&_m0vFbj=^mmh}4%#Bt!_mNZyoW%7|rKGJs`Pk=rh&G1}i)zMK-JZQ}g1e1o*R47eV4kgC1>3#SiJ)4HmKr;f>mW$783 z;Q7+j;#VqsZZ3Op7Q2C~Z675b4@#?yo6}#K>MvUBset}z6@1ZAMJWmlQOKpOaqX}i z6e{cXNCt?M#3<2*=>}WM^mrC+j~Aw>IK5Ubeod&#Y=#tq5h;*+O~_s`cC{6PHbpyZ zlmr>uN(^5uVN>IH8&R1OonWY0gs2JLcH3wc(%tz~JgjR)2{9GcNa^Jy^*M^H1$d#X zB4~|+d&r>JA8q*C*BA+_vY! zB!4!`IUb2NBSTq=%ETekHj+`P_z&a6o%|@pC{`&ITu+w2k@b_W6p2o0W0f&&gHdRB@V&N=MlY=0><{kV)D* zlftL2mEIg_Q*7!$!x}3dpt5{89AcSOV_KSanw-XgncI0=7VltJP8#K}YBFgh+c87N zH`81(@VuW{iQ(yAQ56m!O&ttd+9_iBB$IJFLh3=dw{gPs+!9Czp6>htYQ;SSV00KJ zU(cx!N?O^msw&w+Gdd{w6^v?6djWB;0$arA?NE8+M;TfSF2DcK&G>;-gM#$3kfAck zi5Y~E=n9NBsIQO5kXG&i-<*Gk<|=K>aBNRc%Bm9>z$V8rhlLN9B}~-R5J@7fg0drA z6XFRZaB`LDqGypR^Po#J(#bZ!`606=B5~)XN;#{< zQcVm<7B4jqFBqU1I^jyMX;@|0cHdX{^{icu%}99lN}ns8cwI>tWnXo zPd!yMl+pkrSd$K@jc&FA_HOp$caC@r*O+Jpf@suZ@l(M?TZ7VJh2=(8hs-+}8Q72o zyY{~dnmElXadH8uxmKQ=5zP5YDw*R6Mf}y|s44ay3=*&n4YfRV)ew^vM$|QmLgq{d z6jIe0FNrU^2DgVAc9)n1D3aaI-s0t>Os;>VMXtym=!gCKaSH^ zqcmnC405W10Wzr!ZSdif?vRja3qu+*HJLXEf|w#Aur}-t;75M`-uy}*Q8e;^iU+V< zp+{TQWq~Bxzsu^SA`z>FtEF9}pJn)|$6>lmmf>_XXKcSyfnrzM`ot>Nuev~Um zs2%ke;d3rXld_jA6x06zNP15#PHoNki#FksoV`?(SbhnHF(BeHMqWoGixCp;0Jn)G z1EC{VS8|X5kw9+02HL%?u~Lav0*;<5hGU<|>oI&bkz}5UR+bo6FpNp0k@GU*IBpw{RLx#XOXeD?wf6}O2fzzhanH{F z&YS$8?tZV}LvSiOXV35~2)pre zOk@^S5@7VU03C0poTgymD-~;0!c275E~Dk+^SO~~);6R~&?ItzR0V;ROI&I8xb3^U zDYw%pG*!Jjbo#P-yj^PGGt$dbRWucLvhAduV_?4M((iAphdG770!x)tk2P2CHSi+3(u=@PqTbDDc~+Dd#OiO_g$%Si@$5N$IGmF==QLKy4Wq z#Ps_~KFba#xprJ8uWdRxI#-k!- zh#*gM=Rz4IBWRJZ`tqX7YuF2)hZkgJKbTkezcEOzq%uFo`BidtCkdva%2{0_cbHZ~ z43jNNC^3T?%*?hMh`IM}cr0OZsG`TrK{Qa%;kdn9PlQD2PenPx=W3f0eA;;`xB*Oxd-WkeD`+}#Jb_ke@Fw%4j_qLZMwbWK?+*NLFH|X2YltB}Q~_hi zXmG3|u_F@GW7tfTH6C7yUYeg^V{f2q!xn)ii``Tvm7PMTpr)dfvDzwPm6Xe^``X7# zcI6pSno_i3McFV)=Z=#Ust&PK#Z5Qv<05nv;Ak(IG^D6Vq8(L*QsWh41A-T%s**`2bt7o<1KRf_SRDu;>%kgG+Gwl{ zYF1myH4tOTHZ2muaKApB%N5GJD+pt>AKv$^Z*M%~!%h`IgQ{pr=|)|~mRx5s!$eyL zsdbkO!Dgr4QUc)W!(06q(}^xr3<;%-pv@iMPB>m5ncFed%Y>{+ieT0FYDZ>66k?J` zkdi?pf}jtN2y+(!L=&*ljk+OIL|dsjFB#4Kde7KaAppYa@Ty9BN)IheVrN+5S{ZzG z>`C$0hc=ffOG!Iv9m{06O)q^mWXwM=byFLIHU*=ClMSAldP0{IO!b&@$bgM5p^3l4 zn!9&XVks+agt?7bc1FpVW*wZAVA1}E7pa;WX;q0x;v`)5_-XOrV)6B9gSL;@X(MF_ z9Y^WKJ}-#lm@P|hr_H%`dK!YnSv;IlkSklM!1Vjf+X=qvW0mjSoCFq#>Hj_P&W`b zoeoIClxT{Pk?_sc8KdRn4FIg(A4XkJ3xYu!a+f?Q`*iK4-UkoN*X@!MBs7w$G;Y7X zRY0}$;w3HxD@r8A2quLv{HLk(Q#4xNHpfS9%CAXw&D~>{_2FU|wB8j;<^_3^72~1Z|~`H6q_1ufGr=4RO~_tLz4c zuR?WG;@NYk7?~w&XtBuYtK%V!*ij^en*cmOw~qsR*32y(LX5I^N!B`R|Iu>%K`GHN zZkb4r<|^WG#~ZI}wi{Y@li}NtPVSHLgXQxTHs)vcL(k-Drz!+Xn=r`ZW@%npX(Nh7 z0_4C856go036n?yKq6=-%`(!%gkmA-!p9XzUCsNps+QyEHX}|dZBnSF-cTY<378{b zb$BdoM?oAD{IvdjZmKL--V6!7!31l{6)Rmd1PP;+Sx+34I4e`q#T(UO6ctj1?hLfi zcLT8lUI&7SRM3z&;TTbR&bUxaB3UFmRp&;9M|A>YZvHpnwY!8GCb~sWs>884sIYR= zyv(twV

QRyV!CwzuOdIMta%Cb7pyRJ5|r!M4*)Oz5kj+ACqW?cD3n16L|BPFa$I zmk7ir6HXK26Cqdz>e~05)W}dp4AdRZsoB4EVuUL18;|_*jw1(qP1AZ4Zaiv{Uv$~YX zpl1}y=8GD@s9{MOrl7mUQ6zg+!e}<$*B$$DcyJI;3QAK3gevT@{I#jlq%6%co2AIG z3I&Dx_t%YglUg%M&X(o880KuVio(-;$i&|bsDab;dnBWow<~yqYaS)Mcfds`wQ5u- zP3kroUX}4wB?K|YJdZ;aOtLg=<}HUoYgi8+7hAjtrEfQkaHQ4~HXl=(vPm?8dUT%< zn-PW1(>Pojsa-=aYu`_YA1Wm#s#^hKDQ(qGpjBeIezq8}3R)yF?T(QT=%Pj{peRi= zP&DN&Z30#?r><@Wh@wZ+Io^jlVkVlHc{LD}kxN-a85M`xKLRbo>wq*-BWm&WQL}25 zm1&H03SFXaJ7FLeZ8gx?>%xE)OMn_^0;izGYWlVE*kwdmWd8ukF$pDS_k*aepg<4- z-(DFJ`zbv%icY#VG?{KJXAsMH&OIwt&|y$VAIJqC@5*SvL?n@Qh-}o2PhsLgGMp(8 zD9N@8%uuZPy9dCrn5gR~id@xLu~fx`qW=KAwDPkeJ17=Ve6kdK2eXLCDigw&%2IUB zG$mE_F1~C5=`ifDCN)sJEwP;wYa=4cebR1UQ^XC~f~-v_amY@}3n_CQRymARE+@6+ zq{DFRDxR7aBg+D+wVQJhsqA>=%PB|^(^_TSYBb%R)JbkjJA5v0 z;jQ@PsKRT{ECaHYzMpW~NpYO(1x!gTGtWa@<;{x!0KVmnk?{Q=Eq-=Z+e`yo`p<+? zvCWMWgjt{x#~NPpGwuSz=r;O!t4NVdt;t87MfAs%mk7zYRy$CQRY#21W-PTmKETSX z(?wd3YiLVG+W2zW%le#(rd|e#p|2Pe5Mq~*6B~#5gAf3yK+eo8Ep4L5g)N#fQJg3N z&e@z%s^CLvRY%^x~ji(6Qsg0=_=xo?%PpO zQ&t!Ydo~+zEu1hG={}slvwTIILB8nVNmKTmN3nuDHxLwME4;&_)y92KpWj?VE*R zL7Sz5D3Wxm7Nv(1t)i@uMf0_>QY2H2!KIWjLP_>s#Bkx%VdY3$#%NLX6<0v;;BeB! zh}nNCP{QdCVDrTTY2N2U#MU60CyA$S3B#aJ1zSWbx@kaNkC{nC)s&8;SR>N4#m~2~ z9A1eEib{UkMs+6;`Ks7(h21REm8S@VkclDQZEy8Q6tK{lHCLQ~DZ3Mvz8Y*YlC3Wc z?N2Ev2k50|P2%1n>v6~0I;7Hjg>0ohV2U{D=K09TnGq$WnF-w(2XFu$#fN?)3Op%D zP7_Ezh*njfQ5`0zSiH1c$%4~3MkeU^oiVdtx4b`Z6kjGSmE}z`uiB*b*3q(L+N_Ta zMq;VLl;D|}BCTqQcAjal!{!O)c;Y00>=dEhf3!zq$d^)F@SYSjO0?oBC7wEQl5@0J z?jK8s3S_8>u?R4#u#Hh1F6Bi;VL=<0cBFen^gPw7oVPlXWLBOicxgLor@Glm`jCL23!*!f-NVE*lf8MRs<1a;y638yAFvI9d^{9!KAiUp_4G#*ghqlS>rB?`u{Ih~X)_BXh`q#N-C!+_&U z8bXB|u8^i>{&`0Dd@)m0G&SyyBq1i zo6FTlY$gDjaO$&C)7R1CX09r6H4SV~xw$)1T5`ZJ7S~ITG?bV$t(9%+s+j9m0F_ye zo|1P*aM)HNYM=o_6q+QMp8@YX_VBj^*?Y%M$}PP6fU7a4nh2w)k(FB ztUzn`@PR!8rj`(9sG}Io@a6uj^(u7?DKi|njV%-3aPtyN{Z}J{%QlH^G#9&EEYX1U zX7kU2Od1Qq7QYHi`Kv0{PK3V0OC!%uJWZRT8(N$p?)j}98;OEVm474k@7b%=_u}jG^_MCRfpl3cdBU+Fw@PB z(;~&C?lAOGsJPT7r`mW~yoxF*9aN(zY{HFy|I&2z>U``Erb!h!^1q!dbIi@|hW=ZK z1xtHubUcGMb5DADW9BMq%z-E#byZJ;%`RfY@fsuZmGBfus5e=F@>RoF_Xkn+a9p>N zlLm{_Fb0b6SZiu&Fi8U0jYcgk3jo@$ms=xf2f&^fS_GBS8>LEUY3a>R^GrJt^N=a0 z!{$nVF54Ll4A*1r?l_LNE?|n zA`gg6@u2gl#eP`EqjN0YQVZx6U*5m8YknA89B8`d8h*?ex64#X6%=bMHcgSCEo-IN zYvX<=iKPsI08@X=;#G82RP#l#Drcr1TwnvOWJ)dZ*YoCv6{Q*3SaaPyEfq#0Oaw_3 z(#Fa5h_sf|;ioLX)CE%G3N9Gjl<>tvRteg*^zyVUKqMLCI$ztT4w#cgPc9XYO%M2X zGhEWsnpZ0%QB5`2f)sg9pnN-lr;WIf+W;x$y@dx^pEuUynWH9EAWAB#P_zt`yO}^$ zC|HIkQZ=ygzZA5{N=T&3RH}wtQbZC_d6fxTl0aqiHtrwe}qhZCUTUegsLryZp==vDhCQi&*1% zuREav>9CLk1`BiT(4HJ!f|Sh^Fb1q>*3|z1CBvsmWUrDbLaPKW8BNJw;&@UQOS`eO z8cg7s3Z?pyL!E2sir}$P*5J537VxuTRWnpl&a5r3lD<=KZxdx6CyJbYThcboHkK9M zdQjz$<6|h(K(!`1+|^#u$4x`-tW=S(HY^5!C>Bw|*4tW)4U}rPgK2}dfR33QOC0L1 zF^g7Wrk=W*3JR&JssMMW+VTrsy@9)NZQuxK0Z47hQ>4+uro^k7oBRp>n_SUv2Y<%x`iqr2nOKN7up5=gah#Atmcv}lMyu6 z>Ekv-hV+G+c0^dQ`if;FDtS^6~j9RlhX+ynLKCWsk?bGn^;E=^4rXhx;G{~zPDpg3W?)zBo zCfxRtmv+-&1-C(_Jt4uerec~IL^b$rEK^j^A_sY+SW3a5)Pl%BA5RuB_kd}ahzT@z zeF%Kyy*H%647MLsaG|k zGGjE*HAq_k1qFAybl2S^--)+*v-yPx{vVj9?_M3ygR-g{s93~R8DlQb{K2bm#lo=0 zhG_4#qZA0KVcd;PkF$eDlMVoAq__+kEBPKeIPq*rU>l`b;HgGi4|{g)$92IWcw*o< zQ!OL|G`Z@w1vM@aE+suksyMb8gi*x{i*5pzD-at|eb?8FTD!1xQGPwjnH)ASa58+4NXolnlWg%q$l?)s1F9;&go0bq*SFRC~OV8!zO7nP~;Wu(jw($SFPYRfDO=59e5UDu7Ta4apaBCBU1 zWbmOmNYl2f$FA~cJgb~=DycEYp~mofnmE%Fr#?c%}X z*-L?K^uXIhYEG77{UGYD8-?SMN&KzaxZ&8lT?COdEC3|v8o=;ai`2Z#jkHGFWe$y1 z0zA=$QqH2GLP;yCB(8+&1($WSwV0kZSW)W~y-)Q}@6nvoAM?7*K1o?CDIvt`(4pNK zgZX2xX4)KTt~91d*UIu@YaNk=3S1AfsXA~x!*C*um4ToOKIgm}Gh~b}8^SAv zeHCmN-WMwkZ1h#Mkjb{)h-F}Sr7S^%PBKBF1JufzbDS{jK01P2VOJ5qc7HYGKri0@ zSUf+rLC{4P-X9R7!ZTbglj||1kO=0>m~~PyIs@}H?ruH4&!dE)qpms)Dl5Ytil=_1 zWQtj`-XEG1&5swvYpW{aomITIQV0s$Z)4oA!v4+;^5>-KG#0&V=>*ZD^gxosl5y%P zj5#VAJZiF}m%Zcod~0}A0;F_&>e)6XK%?)QEVPtR(^G5@^PZ!+WKm)3gvcLqz z4Rm=QFJV&oPcqa?f0&vlW+Wq~y{&CU_=U^TMAP4w6bNG(JLfX~W5#my{{YFeNyIBB z!=^^G1~pZTDN~^gG$V?Oi>UJa zX>L-W8DC7-|I>E$xra|rlyWUuVZeDqT1>&!D^F^G*pl@#T4GL2%f318j%$f zTbPMcf26++?Gq!?k-jhjmz_Jr>Zvm3Ei`CnStx1*Oc&iyY1?2wcN@48s?tUjXLAj0 zO6HD^RQX#PC5${~<7u7*uu?sM5O2b?BxzWqcNGdnJ#_?9%||3}a#E$4Dj{;LN19gu z01jH#L7Go+xvujbF;1D9zJ_RGf{Kxf%P4!ZOsEM1ZkE?yk0_>yOx2S7nrj%;a8Xg! z37O`X6{GU3b=MJq?f#B6-RdM$>wG0RS1z#6QzRI@OGp&SD@u}IZN!@2-S*!6y_yC9 zRW6<5MaK?{`GqbH)e?tPti$M-$Uy;~wF44Qa0d>OV`UYnNd}Er!=u0rOm#6U2aLlU z&@g2!u;@+wqsQ68u%e?*sTi6qvx>F3->mcewo?X`~*=}lMzLQYng3T&}eGf7bOIIAp_TSCSNrksWrwZR|{hY(yD z1X7kj)I8`m&AFaN#vRs_(9%^^DW!*T-pcYdwLP!jl|x<`rK@upp=T~ER5`mS)HKA2 z>*t-e>aoc9Eny&A#^1+@okXP5$W$y>KU0~4JTolP!-dX7mHP-%+iptsBibxU<+8L& z={{w`ig!jQWyWgcot7!QqbYZ7gK%Zi=fvNFJE19}MpL$p#u<^K#%mzW7`$_~6BF&F zp^iokh_JZw)DL(<2=|z3dk-5DE!gnUgDEQ8vX|MHJW*syx*A&Z1}W6sRv9ZWoDo!c zSZx(MM+htcvajh>DvtjEQR6K#r5>tSr}UB4Kn+$SSv>W%_0?}xi(*Q+ob@uXw)J&V z0PHMUzz+@>B_LoaGp`JRTh47*#3!lE2M2!{lUC)|%S!68ArWxK8Zt{2+^37Wg=5sgdq z{{W5CLz?rGye~{EC@2y`sZh+-LjLi%)pb0*@=OY&X9EMm!epB2nFeCQwlAj!czM??OacY`lxPAKDkKUtG$?~gN zI0Hm<8VzbXvbe8QQjupSnZ(glQv;-ot$59d>@G*u#SK~MYHLni%aJs7@`fQDHbul~ zTHB1cfR3SyBS*RJcCuSvdiUWi;(u-IrA(?@^`I`h6?&-gXy;U+bfKa1Afa}V7({9% zjoFX*gqI-r@X4gbCUJ6;Rt5NaV$sW!F&T#AB{myFD}2chaQLPmLDI*=?%`Hum~hj! z-X_H={{RpPn-l5&Pk_o$!H&ZsgdN0`6|oXF_aRN~&1A0r)cJhHQuT;H2aQq2K562~ zS#u7MnQ5^6Ckv#e_s!W>m17@QxxrdLy3G})3LrC;Y6R!DTpudxEJC_(sU?wRg|bPTUb%&oE`p4 zH|DyWI}pcVNpRdEBrE2!q!Sq=D5KrDP@}caB7lMn4U~U@Fe;*bM)d*==bNy+J`wUT z;JCF)Rn$ZpQ&0-F-!Z&)4F&sfbCuhaB2PsSUX;uVBNX|+AIX`r0Elw+X0oQ4T2` z%1XP5_idhbCnkR%v3B}^(^gDj0K453?2 z{`Q~5+UnC>x*PHGy4zx)wy2=7@M z!HyJzFI0nG>IG#zPf~Cej>Rcfl88*?uz21XWES=n-Ul~s*X+#IpE99C9vzxzm!BbLC?(1yyIcc952QJyqRQCyJRfFERi|PFg}zcG7boLw2O7`Bk>&HNSp#87Ow zg4ARzX0D2*qpE4K9rVP2S(LJdQhY_baa-txj*3feK?Z^zn`R+hMUPgs!KlRs_-E0- z-a2uw6sf3CuN4g@gg-Ky5y9}NYHDPpSfzTQB^s^eRF$l!;qH;kuLCrl27IWvb!N3I z@}3)Z=`cxPfER9$rOA`KXdTuz>+DCLT2rZmwlE*ip1-9&NI z#UTJ6Zo)WHq{7vQ8Z>Qxvk}olKcdR$p~7?H8CEr`#YvKtZMmg-8bGac;GkQCo5Y|N zk1xiSWoZ4HqlvHo)Dr!8Q=@dxBD-H{&9qi^x7q$nh#jKeMfn8o$o;C%SIku3n#XpU zpiaJKd`Ab*`6XysqNklHDrQ*NmGdL2L*wiyKRymD+th+h5iMF^P;u1q-!$?_4XSIU zpUxlgXl8Eu_YHn7wM>fj>d1-_x_uN;WOc6$L3&w?;1QuH@!HMsJWjPrt4NA6bI(az zish4672gQ?BS^uG#NRFu_V$u^Qb`j=qy+)fOnqCcbu*+!aB*<^YNHmh`uKVg;)6wRssN$Fk1^BD360?~yzY$KiPp&Xy|f=_ z4l&(|c5$dQb#O(DVG`5ItFo~gHrg*^dz%mi#=LMQL8dmUhWgA}Hi#g9J?`6Fy4-m9 zcRFzzS}{+WT41=96fKgenoHElU+0L}06-8(Gy>KJ;@n8+FlqZp?*$jmq~h_%n&?0( zl#x~yli(6dfp+e0G~@Q|9_-W4sXDNsw*ssUnzF>NQRSE_XPB#4gM1pLPj6-I#ENeP z1JO^msc;GoI=zckR@PzkwbQjr)jL!u_HJFlM|%LITZ$}G0Mc8#bi~rqwGW~f67Vi_eQs~*LN6c8)+50Wk!xhZqB%0PVg4_X(=nS z#xG6s_!T0z`Zg6#LE7?dHY`XRQrc<4)>$qqs*F~m*parYk}8Z#7V35rh+Y80ehtOD%7Aqp6y>@lq6bYC{+Q)_ zUc0FaS6b3jr3*X6{mg@Vf&n^dso{mofi1-&V$`Wv)rw-c^Wd0OL=drR2v(^hus1Bq z82fyC-+_mlmqi}3kd~lPeZz6~lDidvo2ghris?%l4{BS z01kT9tidw|8cx{c!f4(i=EU0)uK*GC9unsW1;f`yHX!H_Hd4>lD%7T3!{wf&y$u#G zM^#L+9U~Iq)v=Hdd+uHm?&^weT$3U`VvRGc3b#fW&OZ9548uhoUQxnffHK!oQb9*6 zDMpWU1)*kM*SQ>#5SUp!C>)hhb-^frT6%zvCJ#JSbLdxVFt>+=mx~U{YK5AdIYcnj zO;GcO!tnShp_tiXljP8Vqh80k<8|qp2l2YviK;7AquTybEi>5v0FsK}i<9kR#f8u?M55!;kll^T7sh^7+&oe3ncMj;}561Gxrema79)t*R- zXwPX59f;1#+tMkf4{O|r&Ca9YeR)<{qaCn~Wup2X1?0Gfwq%f1+Ini=TKpe(b7dqwWDpl z=aR0OFYzMWzF^su*0T2`noQGXYMR_qf~uqeQq|P7Paqmu6_6c$paI1xYe*ul=04gq zbW*H%ZYJmhr9#tHpp;w*Aewkht?lo^q^hdoF`~EDirFja;)*7-8j4~{lVP-bH1Of= ziULg*Uu>cCpqSMrS;1>wqOeoNSy>`7Gc}8?ECWpl?0AbbLY8Y;L%{6SSL zBmHw&AQe>Wi^owO%{{|Q03df42_kN7M3b$u<8X9DziGYlnTwau{K-Vg{w#H51lS;&)JF{Jr9glx;*bw zS4Pybrax$5m~HbCIvQeF4!|1^8*nGR?Hz5$N8?913%|2m^wV-8cfi3;k6P7rp}{L)jkhTPp~~rC31?%fm6MlO%U5_-*Gx~)~fxbD9jr= z5_+lU3^UVo=@JzQ43PPo$+&MZ#gE>3wMM#SI3|TG(T&r?oO10vGMag5DrsevVI-`` z07WC%En<%OHBFcV5&2&?4g8XK5au1XC;elu5?Hhn0i~CZYcoX?D({CQ)Y8o% zQ%heO%A;HDsENKjJXjs%iX$h(jS5uQl+#5K@?fsm2DLPFsPmYCV%qxn{W{M9jF!`2vN-oeDg|>m>IEo^d z>Y96{n-`xE%9y8;)a^}B@j@Ah1q=Ec9N2)H2I3=3W^-dHW1WlEjcY$0i{i|FPOUmm+_1Qy}Mst z{7RN(GfGP1We*ujDu}3?a~D~VuwY0{qM{oErM!5FWK2@@K~SNO8KJ?U%NTYfB8jsu z$H8l>9h?=Sf_AA9i|8DhgRh9<5VNj0Q_F5sK}7{xt_hp!V}{`d8@+4+2r6rVw$MCB zek|4E6v_mGIMZiX-j0terWc%x7uyTGX&x(`v*Wt^QJtFUqMrxu^JH&jVL8})PZKRIXkuX zTmX2{NzxBZIHCbDLf$ctR85Cs5LE?|FEXtnX)JWwx{G*e#)<}^8)-*)3TU3;8Qs?y z#Nv`d@>9ny9}CCd%Tljxek^!&SOifTo$(sAAH$Ct#PJFocB+Vz9R(&C43RlED<&a` zoo(zZz-INMLefV~2zPN(l}#EySQPQakSMOrwQ;%_XExkanmXxj3ATddaJP3LzM<9g z6r(s%4JXg!YJzI>Y*b!e8A&XnQ6i+~O96Z8g6C6Xeo0@KJ7^qUj5ySqJW~sxX`rW7 zV^~TwRL)k;TK*u7w>Kl6DKl46fT_5xb3;Le%jYkX4JA6DLw|LkKs$UcIi!hIX={o_ zRn^hrGSa0?dp=&8N@R))lPkNDtV#PLwf>GRZLB7e_tG(@$|`{sB`qrYAQkBL0N`x@F1l^_WIY2-C`oIAPK8V>V|V%M+?nx<{E@) zOvMr!!y>ye4AJT@eH5D>1uU&`08zEg)Cvf)epslhqQ)_*igN+0qjsPmA1p+S4fX8J zx5v2ChVHmV6iEhXuxFn-p)m<5oAkw`+E8n))3NW~{9M{GrwX)+KxLQ=xzjDQtt4xC zeDe*9kSXLA7b4`_w--8yY|&tHRw?S6sM!8X&G;r}%DBAP204QTsKc=sTF#Ff5=V$- zU@Xc-h|uvDrXMXHXu_#QK!GPU5f^PhQU>eo*HuzDzTv=Is-?58 ziI-ogs;fG?TIx)Wk)fY(+5uKEvwa1|oHxr=rL1VS?-wG6e@={Jz`By2YO#j}TA4SK zdw)2h2Se=Q4B0*;#TjL3GOsV4LdIpm;LWv^I8|V)q;RTlim0$3@^=eEMDU7b_c0V&dW}|+?cbukR9ADZ z(!Ks8xZ&NCQAJma9?BQ8Evxc2Wcg_Xb78f{rFSmxu|j~@0o>n}yipDhDotj+NucX9 z^%kN`TPfkVRdAY0g_?&Kqm@SWc+`LeyB*d%^K1YKK9u=b*+@*&nem*jS(`HC#I_Nb zqn#D8x0kP%7DOd(E6zeXO0tEmVmN!>df<6k2&aqY*k{gq&L*(JCSZ7Ny`SH$%;Purk!b*Wz45mS2bdbS)J)|B7^A_RKI%vZyep{r6OYw)p zWyfQpc1M#Cr)G*fk23V@xk(-eZybHCKvI#7Ch{V9x;4crW}KW zEj02YMMFhXO(Z8p2}*$t@Aif5!nLEuX=8562bCP(L7rtz7f~?^q*)dX~4Ggh*CVL(S)Z=bPqb9Uba*nOB7+?DiA-^Qlw6Ga|8-~mMnPd2nL$DbHJJCr;Kf==z4J-98C1{#S}0{44NN)pdq>XEpAo0W@FVN}`4=@ru_=GGS z;$&sM>!>%kZ8@cTr}k!HKeiN&-K3045>@#Tqz%{C)giW90Zs;WxG zrc^#;)kXx01_gE^vxd3&fH+<@QHFy<3YuAQOq{T}@*`(5h8n3#cRn7{ZN@~wHL){A zSE`tmH6+kYPJFoxlOwy3N!ueJKc5v^qHE5;*+aLdY?+JZiRkl&CWaiVmnw|dbr-y| z;`I+n5k^Omhtnu1 zhiLl|r-Jt<>pU&CV662DT($ROu8771SBYX>La)Yas^1b^S{kfErneCwNF@u{lYYbO zf#Ja#l9aXp>7o>^MRezl!~FfB!zimfgrt!S%?ZEh27yZ-8){D&5GmQ5X&{x=bXnev zRzNB0V}_=VB}Hj>Aqi(?`3GG_h(EM=u4&Ws42Nuu`oe!yK}hTEaDwNohv?-pvK?;lhQnCTV7< zgV9fwIJPACE@7HSQynCz$gH6p&rz|juW$rp52KX`6HcW=O*P?Rn<{23Mrws>XQ80m z3b=Vj>iXma`y1UlTb9763ae{Ql6q(t>NQ-Ixl;scY)L1srj~Cu87{8~^3_6E{i~_C zJTkNzRA{Z$o-~B%Jyyyb#RGq$%LP$c?g0(Hnl?8F?&q&|ihjh94Pe0O#V&Qkr&ln1 z^baJg2>WHqi+pTv#sZ}gOJ2f+I{KA39Th^$ynO9VB$4|p%!D7j9(gDMVw*tl#S`;U zhyMUx;iHO}B+D&TJ#C1)4<)JOqTF*>;>e=IEum@dhotQAWDCMq>vImW$tgU#eB2WW}>f{PWy{s$<@Z_q>f`-}w zC=jWjSYzoXFATB?U<&LVRgH-Z6fVDi73rkQaM6vR#AxU+niZOp%=0KxO|k$*tO;Rn z9XMFF$We+gXe6XfH&h38Zy1O!Zhh ztg6w^O-v;Q`$075JA4V{){!JtnQ#FV^;=IQf~uERk=0o&MYKk?zTb};3e#6`1BFS% z@-z%UG^1)!Qmz5Y#*hRi$|B7|Xv~2Ji>K@HB_?t|JOM?zJLo zmIIh^3^yX@j3*kwg=FyHDINt~g`<>?XR}7mzv8x=j~#Kaq6j=`5OakR9Lv78qWmkq?QmXflPwgd0R z!V*;5#2&;Q2-Ai6f&$Tqr55C%&04-z>c(941(mT%TuTm%49xgxF=osU%VL#H3fXHZ zM!JwZHB+I|$ABxw7ij1);h{ac68JE2qQi+~Oiw2DBPvuR0>1#nR<&^4X;kc!eLRG# zkKJ{?p!oLT^B2i=krZBSl-sa+D5LdTr?6pJvpUvPBTrK>rK6y#sB5pvxD_CPI~_Q1 z!{nd=MapMOgqq9I3?Jk$KC;xhT~`KtJ}t)Ak?ZMZxcFH~`njve2`C+OqSI=K=%AjS zX&}bFX`bwBAl|A4#?yO!WN}`QaHkH*<3^(ctc`=3w32E)^H$3aspbcoG`8Sx+=KOT zB9bCSAzI3nGy?S-328-ZB!U`wT_z;hlFZwH*T=UEtuR$3c{ot3(dxIC48-7tgh}(U z%`-r^8-+A#ZV!KFHJBd|!-XZWh&1PpWgNeS=LoU7N*$PU_xeN8UnhHfYf62bk(v%^z}Gv)K=F-;E+7Tk8uW<9H}H2 z%{=uEL=z-I%^D`qSw?{At+;1wbf{7n zh7>g!YU;Ay3y1l_6ns9E8jI+lB3zsN0pW9icZAZ`5JCkXzr*giX|mpaO1VL)lNd}s zH;@)pEr-)4<8NUi{{R8-;4^v_JM>Qx_|eu-f}|^?8voZ^`r^k$XGr>Ehk5HeQ|6dF zuz$)T945RGbNis!at+<2!>R=T01wPm=e!{}C{+`6UlCX{E>~ry6_L=z1hNIWakh7R zTebNiu-H&E7&j#b0NX(3aI9Esp{k`GRMl9p#B1QIw%;~cWDFI41akIlf=yoeUIf=X z*Nx3nhprwW^1`Jwv&}ugA!SzyW8VG#t|>*R6kfL^!J)sZSb?C(a3TTby$uhP=UaY; zHz)GpZI}gdMsIzSMVF=s(qs5k;BWHj{MI_{xnO{O$A?deL85RxT~ux}9a_~Tc!U8L zkgp+aRJPk4zfHJMJ=9>40)cAyrIgXru>x63Czv$2Dn}7HZrh5D`F(P{k`C*88fIf%WJ(xeP+76R+yR zl5+g1kIbG%HShwos+S6leMQHIYjH?!nJbgmP81l8MHVBHstfssmb#tf1X{*PHeCJu z(})@ftup6~P}7Oyvy94MmZ~ahcwc-m!?xhs_qp%Fw721!G*gCzxGLhJ#IQ60gSJiCcr=5!?{wdHnC0s6d|f z+kl{IKqA-UA-Svfi;1AFT*Lg&KH<>Tk1bGEG$t{skCknp-@t_L#Y=4WMk=kV_L$Rd zVviNC%-AGUF-c!6@;y9BN;fgx3n;K(i0#WTkr>mx?ChftmunUALky0gp9=G5y4bV% z^ymR6>)~y}2^8xm#f=0Q<{J#%L&AVN;E}xPOlQGE{{T-MZBUaGtf${cb1l`)g<+_( zR6Sy?BN*kMUvzx1BImeJZ^9Q0nlMVDvqhO6rlzu*pEn%Y>ZZ7Pk(VjRaCPPP(+eKv+d>eK%5Su!y|a@~OhB>lQUOWNNDT zN%q_HmnV_F{{Wb69&|d~u?tujVMp85P9O4JGRgHK`{u?ln6}(&<e~ zEz4^stL7@Z!*o<*ujN!7nK2O+EkaZ`pB!@H5x}+psZ2tlKpxTT_-V;82{I#%0ssV2 zSgMl?pBs`QN=p$EL=xL7)CG zoOJlbCuvyID;cEpFvU@ovB=}HwN)i#HwvRyhFkXdw;W1fj4`S%VA0>IY|~pogVfSg z%~ZLY2%)ZOO8DA8FilSr?mAel&A|tO;*=K;og4%Zfm!Hrs+cg`)k|Gl6&-ZgOUX4b zEWUJf$Yj`~{av=Vvz`pfvDhiKB#pF7amuPX%0(jUzCkL6)TlN#1NQLQw)|AbcnGGf zty@cnX6&;hpt=`yR&p#D!1lki3wGkiQ{W&{G^lF=kXhE5{{Wd&ovh6a#&rW*DU^$S z-MOYxG{q_lI--Z(j>^!>iPc8CB#su{3u?QTo$vJUt@QBWN*h%AQs*UR>~{ggYQ1|zE3Ct{)WMqAZoM=;Nc#Dw)`0BpBP+%DDTE=3; z@d`l>4VWdSTss%02WUXPS%zdkW$q7u;lVag`W-|Kv`3hNhcOfv^v<<^s=Z@?Tg#e~ z@yJG@mZBmpe}(VGmuP~YI%eHw6&(}<$1pV$Gmw%ji#sZKs=2+d@Z!SR0*Xr-BM?!KB>{+*<4|`d`{Dek-<5j%gjj zu!<3STVBz@nBs)_(Ek84U|KV8bS1R6hmS3KJVVNwu@N+@&KRLw$AiP5^J%A*P48oP zz#nnq7V)D!9vPs^G2^vQg5y|ecG*&{B}3S%Mx}fAvE`MCr)^x?1q9elOj2R0!E)3@z9?Lt32e;-L#>TuzO7`9;m^-;U@IMi@qIm_lMltnH#Xx1jW zyCnrFYYz{$KCS`x!@~Q1UyTX(V-zo_{Hy=aa`nweB|cK=)nAw8yW@joWN4;JN~R}I z_>Yeu&D=8iKi>SsP8qqDKDF**nv2PlHFYOGE~t!5>FDKoYHoqO>`s#PYfe4tV(Kbi5*o36uf_~T}I zB&LZ)#f7&J4fNE3--Zn~MHV{bnlb%fnQ5|Qbn>do@L}}v)5^o`kC#AP6K?(-B(+EF zDAMWKZw`t9`bhhlH6%oqRF7L+mr^ammy&Dn)M`0HAZrM2M>EgEZ@yvqcMHf}$#7 z7!$A-BT`MTbH*FDgvBUb#F{tVAj>s*!k+}p_?%KjmN5H8Ndkkv5ufasqtp=?ALS$+ zyA691U%Hm$PBdd?+SaK%C~4|vQYd;~gijSb5lN03WBj8ArV6oAMRF9CO%*gfyPZ9! zg|@cJxK|kBe+n?Wx=RDDtG_GaSdL`P_{M0=n5);~##})ony~1|)KdVO+eANP4#R?n zm`iQxNP*QvExNZ{m2IzM6^d%``HKQpP0|z>JG`>CJgaT#r6s@yJ4GrowR$csSySd( zl_{JAkau#UOMYXXxk-WNNt#g9X(3sN)?#?9@<&#Dygh@2mgRLVac`pBx>?gscb*zy z!Lbovoz_N-vs0x+jyvvAMIg4G0{U@M@I+EzzZE}M;`I=kO6n@6ilUNFDI|f)_taRa z(2Mec0wTQAqm2wXQx;k4D=KO#77_ftA~G=yK{G}Ne%ki85kAxbOBga~o_dNJe9;AC zR2DFxlAYAt-*MF2jiIMJ+xJ5rSP&W+)EOfM$zs873e6 z`kqRf(veCE%TQ3AhT!%F=Uy0;n4~1Znj3S@JxLY^l`#3Lu4y6)1a~89%>MR<+Kwkf zWGI@raBQx!mSLc%!{cv1%pgczp5SYH3-iUUit?VqE4<5((P7YF{$m*?sKcp3`A1FO zT7h$@?l|*p;%TttMJ8$UG}SXv9mR~~M)A4qN4xtu?(9>+Lrn=;&l`eT*;+Y+O9z%* zDIJUoexBS+%VxamgJIiF8CIey+^td=@83;RAPZ|;#cPd6vzvETpLY-rM{nNPi}ZEJDWqXSG5HB-)G%n(&o#VwM~!54kU@7}|WrMML7 zdJQh}W^GJ5O1NP$QatgQeAyoA35k@b@w;{$O8vPw)9AYqg?Aod-xGhN3TdaPj!5>K z5Cdv0q47Ly+8V0w060{fo7Bu#Bj@^T&4OZbVR)7h($r8^(=iVe%S`c-cKxMc_JPoj zR_iVfx1m50R%YzBy+Gquo6}CPboe;l@y+;^tT@99v7b|Dj3&bIh-f*Ty8ZX z#jG9~f5OZ0?kspAv%5vXPfZr7DrQ0BRqaQZ>Y>CbWM*b^UKVL?M$k{+!6COyQBUR! z(CLHbA@WnK@-nkgNc)X~vl-#gTK)%#)oor)(VTWtHxS1IR#HVNA}LA(Iuc!0%q?wi zU`e+Ww8T>mzce>=nxIr+`1lf-*)antQf=;p_S*g&M}7AXDtgIy8hg(8+!!2~d(P=2 zN~R=|Knte+=KjkLC%121DtW@13n!}>hrE)R5yXf{>~9cm{kgXr(@)sClQfE@FNX@) z{KY7-ln5`lgp{{o{{RvkcmhB)tG`GQ*G4lb<4}K7FyR|rrKxbNmffMXfILL=XH_I^ zaWopokIN2o%+jzX6`Kx>u@?n=l9u{(+K!6D`cm_eCQpS0V5t13uhT5pr?W;q%S-&8lof?w315TgYnSt%G_dlDJ{aV z5NR)%^9xksSR={|aiv8v)U+nYVn-V{Z?B5bgBVf**xo?f4uOE$ZS~v7hDvUW(C7k|*p_#v zg??I!BzGi6u$Al%tU+RR(~b97&0oHxBLdNO*0poAcP~>6EfKL<9+IS zYsy0UD8lqVqg5S7#!e-hBB`UxSaaQ>3c_mXm4%^A*0PhUH?u*nWH-5hLSZW0>|L^_Z3^x#}mWW4lcN0G$*K02&Sonzut~0V4_wJo=VonqsBL zBBHL1sg1~Lh~71@7Ivl11AZ`@^^4=n)H1R(Z49Pn!zvfczz zk1pm^riQuRCqU6i6alWWpAXjD+S{6{Tr*5?W7Kr;)JT!a!N-|3#)Xug{?6x@&?dZI zr!1j5)nc@h(?~vN7MiEakP@L{d@iYW3y*5v+@j1?5Ij`3q{`INM^a{~Xyi(dE?ALN zuHB*g+-q<+!rlU`S~E*e<<$61eAMtr)e+P{u_HJD?MGL+0NVUz#p)B$OIR>zo@J7s z6{KltRU?>tuIq3tNf)+&`!B}Sf>XAfO0<}vQy0b-9Jd5YyVxU0`y&BR1%QM1i*YDS znpmX)LG=zNG*xmxneXjj#^f8H_>a@al#vvbYk`Fb7A&~ixDOu*hGo6lek4( z_XMA(iQZ$znzL^hB7#hEY5dwoX#&JN)kxF;#ItS&_PGQbaK_mJlRRS?rd+>?G?C^I zBM8qs1>7#d&L0BYAFGZ&*d$i%oRCjlCUUKC!SmbHO&e}8F-MNz2YBSMKVLMYcxlzW zjSG}`;#X2)6448dJ10;dqW7)k`SRgp}1p8;x!@+u^|GroM;Q7u0C{9h7vS#1~Ikm*n4wVH{P@fo9nnl@shRvW>% z9^b2;aUyETaEg7-*r;i+#gGq|hL)NQ!R)t09va)8X$Kniy2%|z8%$}WH49~Um3Fyf zsRVWdUfi#AYW?j!W(-PfQ#01o{kbZ|ENHP=NBhkhivewT(*S{6eR`EcmP(?lpv#!8 zBv^e-W+PimG&E~V1IU1~3tX?+xi%b0aOy&YkSXR_SwSEgKwwJQ4>&hg_rCr!Gp2?I^Vi?6#bG^_k&mzrpeHZ{W<C;ZxH^Fzv0amr4~K#1^PyXJ zX}nMO-4$ECYUq@`E5|A8Fx8T~Ce}>w(pS$J^Qh!v#8cIcc0QV1*pA#5Sl;)T9kfj2 z0TV$jCLs*8@~VppT6rM>M{;C=jm7)x!wN6g;)+b;Yfcu(gA1uDk&+MJ#TRIiG}c__ ziyf5Zh2gX-iDFeX3KUg5o1Ca(v6WF^FYN=3CBhN~DN>;0#-Hh`8xO)LX>MV9Dwa}9 zUvBNJ1;@biN=Bk9$zIwF@nDD)O?&9EA+) zP^_z{BrzjH@#U7^jtihYc7s>@+5ix8d`JoI-~e#bc5=zmw(} zq*ZnWlu3r+>v6AbKK@60__Za*z#KkwHQiY5T#lcRum93$_3u$kxofBM)5*Wc%oOx2 zLV=>uR1gT)UO@Y(&=*So02k&ean4Enx=iu;RRDGL88apwT|&(asZQ@uV2tgzp5F6q z(49PaD&@!tN%NpB`-MuNOETkhc#Jq`h|gJx5RZyP&^iQ_U9`QsoA%YaKHXQH6Tm#bcBeCRx=S+|gTmA2v*-O2CD zm(v?+sY#j?F{~LXDw?vMtYS$#ju1I;$^#K{4->U=os^@wRUol^GaR6zsQFwxlQgcO zVq!xk;BG#T4k_RM4Z)`h49{i)LzU9+D)Mo$!fjr^O>_5u!6pTq1=ew%@A! zLz-zR9w?=j3MnMS)s9qT+^H@P9d0X!ywl=9QsFpsD)37*ihbuBNVI5Aylt;xz=&aJ zT!oT6%?i_cg#Zc%uvE-j5URl`C8oojX)z~^)1_SuJL0EJmI)n?a6E6v(vrLhro*Xh z?5d*mHGp*nw=-mR5!B{o`Mgi%Ka)c2X`xtY(7dIsw|nXU?cu?0PNve@gwR(yF1YGS zMiq}KQ&r+oR#Vp<^z8wG?y63kjk$Mj(iam+S#4Tz7}WY4ftVm@EAc!IvY!O0 zsFo^hUP#KuP(vXG?eVZbPc&~^mZjrqOh=YUNsnX$3@KrARh5&1&| z6}7b>w4NNeyl9QJrCT@-%3V`sjB1*Ss+qAuDp+~3!pkoAJ5=gO?`!ME+_`R^47nIn z)(1~RCL)I)$KMN@7}f>c9nSI|f+mQwZZH8B<%?T!pDOAHKe8EpL$q`8A zm`S;u6Jnr`3*U&6_~2=8a#iP84jn@#U06SwM=69!=gzJT{{T$|k#F3UUBl?*e=wa} zYTe4nq{?N=DNNNgnB*~q0#DQ3Z@Sue+>J*ZFN$R>n59-3m1%0Q+|5AvqQ^Xxw9P_5 zF0VS&Z&9aVu7v5vp1wegYRy|HgF)6Qm+LARQ$dL=^>}*)X4>IHe)XE&jkMyXF3^!A z;Z45Did5vzkm7YxV%0VBe4G-xRl`)L%vpm%v7dEy1$JwGR_8TrY&7kzUgT^sO*K6g z#9uH}*3j3jO*{oDqMKs?#diWMMwSPgPHfhkO>6Q?1d~dPAEh<)0RmPq4Am5M4~13RI@~^3WINXi0^yys?3?`tESDv!l&YWD9#m8tvh8o zM9Qesq_ZIkR{D}nyY}aXV&C+trq#j1qC?RP*BxFTB-m*&2S-S}=+)b61}4P!8V*?I zXc$dsTRA%_1}~KJ-5xS=2=HcEDB1|y$YmgHg;X00>vTM;cPJtzs^e=(*+-+&y;diV z)Ip2pH>blX@O)bl!-fviv#muOdwyB8WC}=ceMmZv5$44N;BksPu((=KL{*C%PbvzJ z<`vi-9x+!;f*36gB5WG?sJYai3-FaFCNVUuH~@$g9A;CN@i^)lJgF5NwGq5A$%cf8 ztGKfLi(KB?9y%bHD#Dvf@MbESy+h@0qCZpS!%~)fPBB44O7-;cn9<}_B~dnC+>9_$ zeRSZnFMWXC-IPOmhYPc|lGqPU`in*6!--(i%K>0rNoFBbg4fUkW)Yk{vc!-T|8 zg+EO*1|p2aMzPUH^ASc3w#&F!n}APyTie8{%v%(w+PGB#G_c4SR=)|vDn=)<=qgp{ z>MLU*q>FO4r4F~cf%G0FxXfEA+g57PVMhv^h-5n2$fb&v(yY0)G;x&G7v55D+d;}R znInxnY@7pSC-V16bFLpYEn8EDz*$(Ql4_!fp)DY}_l~*)$CaEh5j4|TbMZQGsF<%# zvDw~I(L|6a^V&Z&HNETGL2KAwmqu*S<4i8e&~{R%C}8;BRj7{`%lL$tMmdJGHMn*m zgvu6JB#uHsQQ{9{abh$&aW&o3P7OF2r8Z4C+O=^NZ9P5D89%PsPNxLVSS2s@yr8Gd zczslAlvuPxDDyxEatT462$CxWJB{_*Z>NdwGlq{Evl)A+;kKk! zbeA^Kky7{s@T{@Qv!gU@P^$(XWa@P7@#PVjHcUvTov?Rl2DraSGfXs-HBK8*{*zN3 zML4p8H$=Z`=i0XB{{WjZa0(b!lb2i!N=+fLo{wiLipgcC!KIOxXklTqc+o}2w~A4m zvXP2~CUYyfQNS8?rs)P|TrQTLuMYWUrc+NkO319!NOS_{wzt2tjX9pNuLVs!jG_HM zZ82ARdg=}#hkTt36w)jUCg_%?H{8IJ+B^3a*NPd>t%;3QrSAQ~{u&K421m~rb{Q2M zxGhXlQG+7ASqKP6ECTyQym+}6%p7DB{GI1ibjuIM31Wzu%f$XEZ<3B7;g4K7N`A_+uKCOHjc zazAxn<9GF*pW9r%SIeiFAgF09 z_9V%s?;j3G?l@-(2rz*d<3`&h^y{ZmM#))}>1!k^8H}lGy|lR}zYAZwQg#|%)v99w zMk@j7mq?`%J7j!3x*xMphQ#d_ISic0yk2*v!w@LMYhzciMfX;Ulo6o<+sN!bJXf0L z!I7mqYW6lLfK`B_iwCE!p3OAz!ImLf(w&vYK+Ar#v?Z zt;6awCSRk*HZIwqcml-FxRIs*06uEtHMj}`RXD3g6r2-7ulbYd6tr={SJTWh5O|zT z9URJ7TKk9ZXf(0o$;=%|omkQ@$|5mN6(zcP(|Q^ir>W@<4S2x`6&l8F#fVZnXaf(= zk2RV+3{5iagLn~76xjo!u}2%%bn^@I6&6txQR=Q&?45NNzYGo9j?+nzZa8eEejn3b zn26y>I(3H8TXTMj1!4#`0Pel}@s+%?Hkk9RwQdIr%l>V;SytkVWE?6=$fWaRs5H)<1~*O;y%Hm9n|V(O!{JEV7J=g?aM1c^)`JI^V#T`Y&O`?p-ZrH6LlG zT4)X%DL+?{Iwu`xl9>|Mw31UWo8~k|fqppPFsiqdn6^IzprV0*}K=4yn^t%8w z!)P@$_-!hzX2f6YUrT-5dBWzIlS~Al9hI7+F7#@7;S}9F!4NP4nlXmc?YXyacGo`M z7rx`6KXLcchMPb;DZ-mCbeJSQZb!kX8cRm!l0E^ z(#B#!nh+yE2-lWjO8$}e(=H+g$}9N;3Z=mFzG0sPpn)jo`A91wjyU7m8KxkBiUI6< z=s5Ojtw>HYN;2{irC}71^~E+1OOo&!=___Z_|6*PW{|)nkkMAEqL{~fuxobHi?=;8 z`s1VKDGu@^mJ*}D{EZY$sYjOTYRpncPLsX8_l`CaUr}pdD`L>zlXd0)4b6XDn|_>7zB5@}5M*Fq#Q)tRD-h zr2lfKYo|Z*Kk1EBV!&B-3kX9u)01PwC|~TqwCm z1*1p(DUE0;8KwlCJ>#w2BxO4WXukktP1SH=p)#- z4AxbTzM39uzIAirKH9Hxgz%?W@@GzQbn>b){uJAY2~8C(Bt-3df;L7E=fdl^oz($k zdYUn`LI9m0(=@#?>4qO!H9*SPbu~ndx;e_k;aIiFRbX`heOydmc|XPRr73B(pR{`g zaD%704>K^LhMJ63#k8zc(No4$F|%zY0Ve0S!-`wJaEK}+)YAspDa0gu1!br7_0wFp zJ4+@VJ})q2W&UpILs7va*eP8mQOYwV6%`&{!VzE( zJDDgboqRhe@oK#G+(W(wZyjwBdn9UkJVuB#ug z_B^n^Kg6ogv^bEOO|D$&^Ps*PgVw`w4LPO5=@^G94T%we2>2a%Y@3N2X%t0qlLp8& z25Ncowi8=8KQFOpD1_UC_cvSHhcq-e~Nt49qPVoKSzn9veH@c8jV$V!IUtu?F>7*IW(utvj& z^DH7%#i%J{6#|;H@A+dAh6ydNxkb;GB)4byJne|SK2iP$CnpQ zDwDNn+Hoe5RM}usPc-!TWK`8oe8-+C0WrJ#?PQect?j0quD7^T{o^3d3dLE2<3BY{ z^;kr{T|4=k5+K4$oz@^8!@npL^z1WE_l+$(L{}VjrKX+|(6kiHs?|{k6z+fmcQ|u< z5pl%gfDq?meBkW}iE0$1K(` zj6A7lK~a?J;F7y8Vib%J`7$q)YaJLVWExx^=Z?910%j>PSa2OG7|~4YoESb~b)uIL zj)`PGYZ_P(GHuWh%ERdGW5ax|`}n4PX}g;hDH|~Ish*i|TqcJXgA%EzHPx6^ej)OH zR?yGq;j~I*J8Ui%Fb(`T?sarYPeBx2V9Jsg8)m=%)GnUAF#4Q3r}+|=X`%Z?A4ZTa1vKm4A!#6*})@fmY+9e;T9Q`_;ao^sgDiA&bzOM%@_HcX4#K&KoJVi`REvsTxL$3BZ-$DoJ`d2yXh@e>|<+ zXKp^zTTb%4l)#T*si*NL^%+A^< zWoj`a0L=y)AZ7r3UzR(SYsP)1s5hPYnD|nHPsJnELZkv39JL$9G?6gp3{AngA@$VX zj2+IjJwDS;r+MxYc6)_5L-?h7t(2?PQ02)919@yUw-Tb)BtE>Nw>sCa+G)h^d*gui z3YPx>inpsOI&^AiGTl1X1G-2s)?LE(x%d5pl>Wt9_4`dcjqbYW9>GR~(|4@jSN&8K z8J{@Mh2b4Gp?9XE6qIr$W-(S2gB>w;_hO9O&63~ht=H9ecNJ}*&EenB|(N$LsQp0y@FHiL;SjeqKqtM1=z3Yw7KuXTixACmQ|#a z=R&I++f=8-;PxNFmUx$|7;!V_9=+w*lAWAWhOMWLVs>{0B__oCM-nG>5H_ICon2Y8 z8l^4(Jdfc-bE;p6kExEG)g~X7^M+H-)L4amO+7F2=+d%C=@Aj)X&N`beF;815@p+y zW~n74M_HhLcf9YkQ>8&tdMOn@;+yLpk~OF_*=4Lj0q~ohqp&{r)59O^HHR7Ynj#z9 zcN;yzpJV)5{aDshi5CmX)QwKjr18UphVvQaNbUwb>$$D6P@(HqMzCSRdzfneTl&zW#0X~^EIm*|IeCcuHGhc@o$Ssn-4X~gd>$l^VMpyoft1J)%JY3AdZesjFa z5A}YLKxI2e*&L&Lqh~lzwAIe>-1LuNrz{WgJoSZ&MdmImm)2df)$SMtAh?WP#{I^e zan01TIAb1WsGZ@s>h=mlSAHm-v2ivOm05=c0LswI^0*x&Lu-U8cH%R+wqWc&(@M_s+^FLo z!AY!J@h|n0NhL$YU6rE>NRY>r@ZRh^K^$Dx>sg)$+G#rT+ku82!BH?D#ADVSbtPz< zHDHA_CuUus02_q_*m!Hoy}Gt%f%cl)d&hJ*k6@@Uejz@qu_}Wb<_r|LU^k`#LKra} z&YW!SZH#O_(@wR$cZm@r*eT|V*Pp7&S*xmP^F9?FL~bZnXs}uoJ6a`TG#dS`Z9AW0 z4hcTfP95yKP>CMFP_a+MJJzBGN%QU<<~T7n%nE^6r+~R$C`Ren#>4G2iOuD_P>CMF zM_cgN>o-}t*P1%RCV$0a%uj;R;gvLR1uQhH14&a+8CykQcLDWVflc_!T4A>Pu@l!q zUCqp#xKjJh9aL_;dF9z>$~Y^^Tlr-?)KV=zim}zh9a`yb`=cHFI7_);qUByxW4w={ zcG1^9>etp@x^YpiWqro%P zH3dG@mMA}z(YnS81_5p~?s&rYYRs8~x1`gb+B?NB~>ThM!LT#@cZ*}a3Fny+yuXyf`5i+-|zgl=$f$4gKhAqKOlVBKo-s0x_ zmtMn^JE>%|h(6O*PV-$SVIIL*secrYTgE?kKH%}Z0Ns-kt_Y38@C={RBR6fE@T z@dfn-iop&e)E>HFm~f`8nvSmrI3)r!w1Ec3+!R>c*d7;OZtc5r8$rjejO=rlUQD>K z2bT{@GW5Q?DDl^g@lLhFNew#(j&_2Q1(MI8Q4k~!{2*TLl4Q0|tqE=ORy2(+f#_;B zVfEby@=BO!y0=2o6_z?VD&U4^GBW5zlJ_TFd8YSsTEw(*>lE{uyGRlp6Xa->X3t(e ztZJfPaqBfzZ$0No_6lj6@f!7^ zLsC{AsM7++YVW~l4S?3d>!&V_%dj89eWs{)qV$|pJ%XR`kHlNnU3`;L*L4z;5r88% zl{O29S${}?8|?o8TaB-Ca`gWI3HF+>-mBgudj&|V{6xK9(^0(|=h|qHu@WG`u>FpJ ziw&VZ9r*fpV$Xt4w9^N8E=idl!BA)XL%m_oQyVu@X<Wa8Cs#hDlb?KIE!j_jSI*ePw7ePnvd%vo}yFj4h-nu@-R zsCBEuXpl^VS+Y%=( z@ecKnl(1H>Sn5BVN#-o|KP5(No4wI(me%KsTirV%XG!*&W!>Ys(gcrSp+o(;y=hQk zjaL_0>eYoLHO!4gMpo|-Z2?U?@dx&H%ox&rrj;i+xhdK`lpM$Fht@`Eu9_^z)#>pS ziZ}fn_;nr1wzecC?Wb-jb9L+hoicpsrZHERVoRE;pJb%o=l!>E-UgQdczx)W|u zd#zxp@Ska`o#nk76g`xd%$}xwN@Ct);=M^}jHQ)>(9$6w4R5tQym^h;vqr?9Z6{Xo z-Y7v>k1DcH!rwCIZ0(l%lZ$2?Vey*WD;}PTjBG?DDlptVYzP(sNhj;%d)g(dO*q<8 zHjkYP_bTznT6136`3nElFTaR>CsdgmAx2eK3`}l{p=Kb5E-7j(2yI2Te-2~*bNn{@vGjq)`^JzAuP5n4$|yrKq;8Ez~*=QM1e1Tuo+>qd=p1RjzJ=hUrm+Ob z+e=%(sP_Fluw8Gu6r74L^yUj4nG}(IbsikIdEu%pxm5}@xO}w~^vt9roybrxU;**t zL1t;fncGhC;L}G&lM$nJ`uEVr>e-r~Is=x7lBK=vSC#Wf&uG!k6XNJ?tq%3OLn;V*oFlKtH5*3aSj-J}sQF3e3@u zS4)lKc%%H*Cy3UPUEPo$paIwcpcdfP+$E$0frSEYbvR0i#M1^Jg2gm-F4W6-(1qH* zAblKlO9No0QlAMmlNQ60jmG<&u5JxHN>$G{j;rE7+8iXl1`}2A&+V4q;ny5-C%JQ^_Sh z6(ftXRZ^&7?f0$Y@Z}1in%a}HpC_O$W|Dn{8Nw-jHXXp&a)Cr_t(4R4HXR*AlxqyW z;FNC>-uBq~+x|?fuKHgmht&J`^SB1&u5MkcQ4PYxL zV|Cg=zx+##Tss0yS(eP>NG!#aE3g{MO6r)(Q_od1NeYh79OMQ1)qx*R6g2QsNEC_7 ze;70~t`Ly<6@@OdQ_2vaumN5%{CJs0MHwOqq`dfiHMKSItYyTCu??2*wCiqDy&z*s zOKDK*sCjP$dTcurgvL~)9(2-Ji~f+G52KIkoM{@{AksGmr>Ul@#vI3}k(w}?+$q_o z*T-BlNy2Gahv4-UG?n&~L0UYOv~Meo$Xj>kZZH6;9%N$h+5t`=^&i;3Z<<|$@$+LXuxiTPHyxQ-1o)6~Wy zJ8PJ zcaV0{_@?|@2#_NAkZyOGAialnVfXgt(%{6?PQ+4`viiYGBE>)?Sdi|xUch$aYI14t z+z71D-~_cCRWxB0D$=0)qux!szh^b9Ra{R^4OKWK3yNh}V2IPeWRiSAshL9v#AWop zo)+SLbgVXJleoPFJe9OGQL{+|Ej*Ah+Df5oC}5*THum#qQHp8A14talhDi-^Wh9FL zNFUM15~3=hAX1ks;cT+ax-xvqSNA0Gw6UJ!>gSY6tpNtIV>lXZ-KEt@D|6k3oU3PS zR?2E76N1NGG?BZ6FjK3E7=~Mt+8?KHE~Sx8B{-2uEN3jwM>Mqz>*Yr3h{z3?5hq6Ev{OJu;UyVpyP*H6&P66zcOvp@0)KtS&r3*heB!*b(!*=UIB=F zg*89S$s3dAL>ug>J^hyBt+}Z)NZxNsqo$VFeirfNcw&m9sOqRfR8q@NaUf(Q3layjUNY(uut69aeU}PIP&+Es`YoTZ zF0Ezf>5h4zr>U#Q=_jTccM;MYLOORTE5pCUZQc|cskt8SXwx#YU6Y#I`$6_pg<*1w z_WQN{@y|t8cd0)~n8!x*bq*nftk}m+vHHIvgArvWY6*!X(^XpbWw*M=Mi%6Wl4s)K zuNU3VRYzH-N~?EvU`;10GE_C$L`6KHJtiFZtpvy}H!$~?=>Z7i$$AwvR5C&Z6?(`& zMBzoYsB52PtS!UVNTN%DM#mA$6?0)(X$bP*t);_Ot;d9aEFRxj;U{~EqvnAr6oeRJ z99s~qr5jd2SrG{Fc3TUNh~v7Z~+A~4U)vwWlfN|kaqTHbR5~hQvyi_Qnx;yHEp5nfdI-vZbUKhmyo~!p zNn7onubH9#Ah+nluw_?)eGl(xh2CXnw}+XuKR$wBi|)}_?zF7&7^{81$?gvq%zRQJTmNH zRl+MQoz&{yKMpUND@ZZdNf~fy#IFv4e7g%@PkigI!12)KZ%sDi6s!EZ3_!*9NEP=0 zKFD5GCmOU;NvQ|(xlt5G86LsA1IKlUtr3k2I7SvGrKe?>MK9S5!v6rcJ74JI1;aI{ zG-kS6(gw$%rNnbo%{E(K(oj-U29A6}Q2NBL`>_w+e}#s;ExNo3!8>Tm%E?MTEtF<6 z$5L?qn&8Tmn0!@PvS_2ja7rq45z=9F%7!#M27wpAcPHySAYp|*tPg~3>*uP3H%}(n z0RI3N4yvylVuKOQIhI^w6|8!^Mt#+l^;5AeBNi*KhMvv~nE|8(je>#~C2Ay-iLBXg z1*e*y<*Ja0XOGX1O*ZTnC+P#5TFEs;Vk;V85nQ=lwS8bKp>wU~HwVZ$|IDi$}D z=aU(xUoP{^vawxlqg!vo!UX}p03hOFBk1rS^38eQ|GI6HM>rpK* zivIv9Sd&|8J*uLQ-q2ds?euX*Uva5)n>4r61}G$!7^y1ho@iLWOfk+O7rbSx#QX=3 z4K-nf6^c+})HJS?)%20xlAf-aoxuPt*bNT1?aCohPAG8{UAl-+Rmmi30vTLJRA>lQ z;-&{pGVv!GRpnYS9u=e8 zjciD#tUnG|O*oDlq^zwYCC!G@srt_}NEK$&sKq65%q|zj8m>$2yTfg7p#XjSs9e*H zCmI;~SCeMN@!VqzrG1k@LtTq9Aia=0f78S{g}_PyJOHXdRliLwv|zZh2LVDKP_oSg zd47_Ls+A^S%~L4}xU8fqmegLvE}Thj>?;a-<)nng2e^hC98qCZO51-bL|We{cumuN4(^Qe_HJWc<4xBKX2QMo8YR zpl!O9{{TgazdMdm*8)sd+Y%z7R^SS?QqV@M2FG3MhTiYHU`W%RLz7!lW~@K(>ByBe z5_JKn>P%BG!>XzzW&_GtYo`Lh3ya^8{{96xlmXN7G&tN<2Gp{waQV^v^}NC!o@M%p z00|a3K`ipZdy_#ru>k!XD&5q6(1X$Q6nlJhsR|#``5K^dQo4`>5I-$lRc`@rotsh# z`Z+43MMaK}5v0~50xe9$02W3YQ3Ze@yBVrp*+S{MY(EXq}Y{ERCXVvQ{m0(fla(c3Lhc_5hvSy$jBF6ZY(&KlqBI<U$ zHmO!BbiUTTt~t4ZTUvHfl7@{c4kHYMYRIy0zK7ihLEnuNP8f=LOgf&YG3Cl8x01{z zF`s!|77{=|She`dmO@FZDFI3Xh8i5LSB}d{=_GV@KQB`CTY%iL7)|V00lVn%;aj%= zV@C~I6&;!QYxh~#U)gP zfHot6Z*T#qC$~J%F*R3IkU*mclxD*rInF91CX%pW&relr6;%14Y;>?Y_<``EM@=ub z(+3Iz^IaV#S;W^AO2zq_gCH=>;O|$lIud+9;gTe#D6zs4sjS#81yzdS4M~TOJ=<(> zl~W*Q18s$`uZJ5dgG$pHDbftRjbN)JGt(M+ygUj?kfG6+zP}z@P&HDj%heh23@4}k zH_kW}bl83|gw&bo@d_3(%>?n(OyWgku~Tp@#CFLGacNe=R=RYdlr1|!!{0}*)Bgaf ztgY$?EY#$lrBl<>^%jzl)8m+ZUhg$12w$apVJG6rMB@Vaw}<@Tj?!)r(_Bu^_^HFvh5 z3vD;$RXYV$T}376=G?obRA-b9*FMX5aCQv_~Q_#>$Ea;}lqKY$r*}%Yh95gNr!(jDMbEcw#t~LD-Gs1VS*0scBx3}BF zLjX})mExe@qK;fsG1k$E30P&Xc=aP_R*}ztqmF_CW|=7j(4Wzqp@?EWMNE<Z7^Ue47^-%&w{N$BJ^M2AeqS>}oy$&}cL!g{ zSO3>2zlgpwB>g4JRIx3#M# z{{YD;;@Y-nv3p%0?Ty*V!WkV}BjJukho;ZComol}uk5mO-IEqq6*M z%V-r-M;oENE{`+e&}Q7<9JIMc3W+K3stAK6Mmbj*Rq`M|y8?f^P1t>rc04A&zR`kl zKMGxAW?WS86lnT~)EZ8nV3e&-OAF@ALYZNp!zl_aJ{tzoh!s<^rL^%U@8J^`>bP=0 zgO6PaAG<}XdZJc#4vu>0m`7iTW6@ONn8jOHS5^k7sjI6uXKmzPUuCo$6QQ)BAS6H( z6;rBo>QRzv4IOetS|pR+K1fsG2`t_Io;Xp{R9We#e6c+bksPx?eCX0DX;|E7RH!4` zJ-pMpjcGVj)?>mFohGD=GRG_}P^jfkcv@4a>@UXIT#CDigGzjInm<04qFB~A=wvp~ z2HQT?H#WJk8gV#T6H7`46$-XkDW#&S0?p*Z62_PJnAI!Tan`}pjW+k)g;+LX%k-7$ zN0>2u2+M%QOtQWeRP8+SNlMP{8_PR^W=B@y2F~2BjxXSPuKJcH}rALhts<;xWsZ5I* zB?77{+e71Tqk{O2loirye9$cPcy%GE62}-VB4;;w{GHgH9v^g#mp*!=QpV z3LVWgM2rJl?3*pX@Zy#fOig**FsIxiHirnowt%u4#c4PFmG=$5k2Ml$vWiyL85Ls< zF61tyS~1)1@25Nkcx*K1gOTJ5(h&l!s7@4Ox@(Q536EkJjCCGPBZyJYhT(>sT)Q;zk`IN7hVS3E3h!E$ z!0V$c2Rvl;P_vyUpq@HPhW#vQ0g|#Ny~rZQ{{Rid0mK%_gv~3sbu-mP?z<6+d{&)d zi0y(FDy~Vk=|CEv0mG!C6DEnngsTme3R&o#9%qObhz-$})tcm9_V$fArrD>Kpi@{V z;76iqmgVMDX%+2j?{yZp#e8{qgGt*)plS+Jm?oO+86*MC{5{j9zOFu#BARp&vu!9k zc~whI4nI{q?-lDpFOjqq{{TjWTxrDDK-0F-1k$hPut;hHrs<`rPnNump}Sp=uwRTR zr#Mp7DF8|6s|)-y&|*20tzKMWS}JNfUnz72U2y`({sfC#flcm62t@6ll?iu9Yg+uM z!}{_uQuOaBMHnE>j?y!-u{xS+hd*n^+#%hCAI*{d@61qxI#!!ho-^__Ky`Jfzc?0f z7M`}Zat0fhZEU^38&KpeA^HD<(CDe5rA`RM5>)nW2#8YOT^Q?qkwb-6n8$&zZWiA>T| z$>qmVkvWl`M^dErQg8Kf^(Puil>#ab8!|Ms#YhtQ>8_vSAGek$!m3r`6e!a}C`xxm z3-6-?e-bQ5-Na<$OZ8z+*mM#>i%=JR@U-Ds5BRJ|x6#iXm2`^A)lyL625873x5UW4 zH+_fh5aWl1H+QPw0p`eSAxBVJ4nr_{A@B=3~byF}X0xT8Ws< zwJRRj$r~0wF55?Y+LMOY z5G~0dYipklHiVd`RH>vph+7)0A)4_=54aQ?ljb$`__rJeneQ=*3De}$JDPV-^mUm` zp?icnp8n1${t88;ca$XKxc(u7;CPiaJfAHFH9U0G?6%&~N4iw^fw*D2h{7a^;YLYz z5=8bH19=QgGBWhePuZ+ z@ytk7V15_j-O2-q(smuROKWhXI1~&K#;voZok_woeov*sa~&e)6~}2Kr_5L^)-hBW zE{^dl9YO9?Y8z3fBMbb!c8--J?Wt!j%#)cm66fC@-&`n^dV}=&QPRO(nzFS)$2xI} zw3PJqXWp9(pF&`$+j0QEy2rn64KghGH%WzHu|O^2$Xv8u&k3Q^IA#n*vX)w=!|CbP zSg7eKh^P!wMHEOu+6w9j*NNF+7Zo)7w*)o^RTi8UuAVlntdJI`fn-EkR9rb0BToQ( zaMek|i&8PBB+E54b@_)DAcz`z>S$TL+pNr?Pu3jr#dC#UyW>N5L9o0_0mZP$@yJ?+ zo~Eukn7}LVh^kQ>fvxmEUkkG(1t7&P%Rxy1owRj&yN1hD@L^Qb8R{yegA>D=nFDX9 zh#zp90NcX@@Uh@`FJBru%mFmN^iNSf6H}U!sxugTazfF#+q4P_I}d>&cpcv|JI4IJ zW`x_DZdS{`<9vmG|Ii`-0EpdigCo$>JgvGq>^i++Z8kGX@%wfAT5=2ABrHgs8%5~H1>3%+~wDJkljSF27 z=%@AOuB$xfKRXZU)*nBWOARO~RgYE1RQ$CuBS@G1-eIDTbX|^x`GxRAB_|qNV`5!0 zMgY;c&pl?rvP~bB@I_sijXL3(a{{746&@W=5epn@i}oUqT|2Swdy~Q&TNOTf6U6k< z+qccyryNzlbWuvgGafCOT6{+pkz}iu@=H)oj4Vm|J6H|~+hGljDZo%#;pI3=lyT!t z@ZxeogvAjybcnQooh~G6@xTP(TWvrlDhw4rF;xUg{`*H8ww}wK2iMIiYtuB}hu2j@ z<&~;!P%fuIv#{gpY#L|2!YOO~`3*GQdpDmoG^^(p-MeyF-{HjF*yyK2go!5_6Dsky z%s703AdU*kK^o4q?Q-f109YM&Sa@-O#*<5X@}W$%HD53CH7^&R6&afe}N zI1pkfrx)TLb!FMFs15Sei$zc=Wpz_hwCKnh`)0W$8-sIkK?o+8OB8Ky@DpS47U!aT#1fC(k2X(b`dY!=Ke2r)_6cw3rL!n}|slQ_*SB-GOR z-=UQx5=SgT=X#U*a-z2b)`sqlOP6HF@m#-(R6MOd3s($PftK;rHB~;-WBw2c7V);85m4d5i zEvpZ@{BkOyoN~N~^_A2UNqxy2w9y~&68F>U2cA-E$ihboi;C3k?_TX3T{6niMOgBhoX-=%9YEF}Hj1bPQ{t+1s*J3s*x>2qVDCfradmAGQD z&ib-Np3VMo}OK&V)6;1u53tPRopkqw6fPqkQ{NS`pw2~xKeKidr{*G*nDTS=+ zniJrzsq&|C zRVsIXh$#lw@CS~xjVXalTsjn@X*n%T;%1N=G+}IYy|e?4QgUmCT#9;(R<)JG5|%2w)sM+kZvIsAs`n&_%XdEzIP%pA!jd$QrP8Abz-zNUQp(j8 zF#iC(`JST+nt1Q-7_ea~uiP)hjyw>vJs&zVwX`lIb)S_bYH}tkPmf^`R-s0ycV@Wm zs;0zW!%it~={jUp9J5kfiWe}94w3LWQB~$%515vfsfg8!?;!gJ8cL0AKy0Ber9v9f zO!c^8n4%&HratpFmayII@5V0HQZTDpq!URVvP~=G$*8F*#F0}~R7hlw!}Kp(C>wzG z6Ux}6YSmu6R5zq-6i~2=D!FOuUKtEgMD6ntskQ8++vwMa${;8TA|S-ki-$7R<=m^5 z>agO}b+q)f)iiTbx!h-1*J}@Du1Miij3vTB5-8cHmeN5vc2q_o&!q z9vhqMA$&g&ig?v%a|)19w25#QR#WeR{{RvkkMkUj%)Nc%M3(2(K0tixPRn!lbB6nu zpgb^>v0h}IzEl?V{{W|W=0i#;@U@mqq_TXNcT#1b8#ajKKjE+&TgQSNqcTI&J7^!C zWv<(*BLPJ{{?6T`#2&7gT+K`qXV2WNlIEQDt*aMjnDGxZa~xq z(EDw|mLDXZsx*DG0Cd!>CjvPw@c1h6d9iAWX{lC;tHT$hrdd#JQZ-}ll0Ceut_92r z^H$}*xXm0KQ!(JU#wUU13VdD!jM7O*PE~_N8S>4M7yMUkZ`%A1A*H1xQPP$S9;#9L zZhES0cNR0$HBX(3HB8j3wha%JPJymHn}GWG8Q%2xk>&HDw&bWKw+ZR_3jfg{Uy0=m zR5>pT#36#wRM+9~3$bM<&L=^y_<09zAyThD%|9xfcims)SoDgdY!M}zd3>;BS!GZ_ z?{E$$%ajjQVPOpQ)N_)vqByuxqFS(lhr`l$n zQ4vh|ULuiI$5T6nD*#4Q-I+zKFYV*1YY49;&;~Ui#V7Lg_d-bMBu&E2c@q4!CRjBA zAg+q*D>;|t-Pdp+0kmi@@H}!;RV0H#6=ge8%M{O4L&ywMJO!1z8(fa|w~rEn4_zz^ zBN~-F(h3-*T9%e=u(U7K#OWT7-3t zx)ouY^rY+vJik$XsKh^B$NnS5XB*qq9lfBY2kL6rbN>r4}cAoD#E z&eY7YGRS9XB#OgAqr=(>9J)cO;%g2kJdk3zT~mIEB9V+r2A9~&az4IYDUfNUeZsNh zn5dPZko)KzM~1qR57v3)pqaw7>dh-M)*!8j(5y^K5j52$h+Vdbfp3nyZD=B{+k~7c zj~AVUD9psHQv?7Ls4a3e_VZygP92j@8D9~kp~S`^Dl;V1Qak}}2zIECQhttAXfYLL z)eZwf9yOY$tEh&qtKNWb@=*K4Ze6}3wYb|&goqV&zo^nWmZ55K3W?%fv6$1%R$y!y z$k*=Ukx3As7EN%1Qw2>?i2|cIRyV%u0sMLBr)Hug)yEY|>N!HZA~#>4GaG62>&uwa zUc?!x*oxFJZ_$xrQZe4=TiV{s^GS)un^MfpJLJ4TrV(9-M_!atOIa+lR228Nm}3?U zHNKX&JmO(;YV4d1Ibt{@)8P+QOIm6LGk$_c79#gL?eFa6NvAYng;`hOlM0MOHyI}R zd`RKtRn<<{{{T77@K{{R=}DEE6?(`1wV_sG={;uviVIBV6)vM{Nrs%YgpBW<0_TKb)I zzaWXq|heI^c`|)oZqG58%ZhL(kV@aBH140)~zn0>e?+i-mg)JjR zP?OZUivVF}3u9~CsN#FXs5WAhS%Kb(rp!&MD03B3L>UCqyoFC~Q@y^9UA$5&ZVf7m zO5(G(oD677sgdQAQVNYPf28qCLXbQ$uF|P~Tq#1}4|Jc1vHGvecS4>qPPuwf1h|kg z1QiII?gqOhxC4}RI8_3OCmbnJ^IN8l0C#zdZJ>)E4KMWZuqn+(lXKUm9bJmV=-Vgq zT(I#mi8imo`kp%k#8WC!7|?H&D}_!!i%Jg0nkmKDT%E|m-%lTTpb{x73h`0p=%!V| zXXq9!nDI2U*fw)~a*Yv7yTSa1N@KM~q?SSe_;4AUyrkU#4h1pqsRwu3N|;e2?K45{ zcv?!F$$(;Xusm=^(1(rofR zBU`r(k82`Oh}998jZ~HghD?VF_IP50H*O_9bu*-SpWlxQt;4@dQhs7QPFa~_iB&d} zunTH?am&<5G|ifiPTEw(hb}pVW_l{vcSDHJH6(SC8z5Dk@~`*@8;6e&n(s6nE= zh-JmgQptphp;1vRvQ#{fwZlUpJ9{4hwmdfroM@%i^a!PvXsjmy%e0>@X=!NSjx|L# z03v`*zK+A*izS?GbgRt$Q z(4`?^Nx+SjYh5GiJx5b8T70XY3|NGVO&twHwRXIb`DjBBe%7pa4))Y?HO%tg$*)^~ zY1<5?;;5&pD|U!9n}U)rq3jO?IaX|! zL=%kzb8MMb>Nrx1JyBMSUjTwSxhm!<9w3{6WJmJCT-xD5Hy7n?ib7SwuIMBRlbWky zTw@QTtwm~z*)aHNfg1bM2#()j7P$D^nrt7qaHk(w*m%LkWe|C%RE3>yF z-S(6%BY>$3aucbC4_$x%(jec8O3h8uOctoO`Z=${>7h_>W)(6q8u-{>kcVdL*K&M~ zO*{Nz)DE#!osz2QMiD+<~GKm!_u;?Qj6;?IT zRWG0&&&KD3*0yT6Q6^w}==$dA3^pP)bX9)VV)dBjKZxTPtxT1bm96H~RMcFtV{_kK zJ)RsDvdU1H0tE%GUs}wQjVLhKmZpi{ZsX=1HMlG+d9?s3DBDg{kh!L-W+!#683S95 zZLiVIRrU(Yw9SN~#T)M1C!WJV8+owP+kQ}^8n7k_tP~g$$x{fDBOd9DuJz3AbhJ)!G+5e61=d(68SRw*FHiq)a%5hMxR(D3@S!BH80DWiI0>%R#X~Y zh138n2e5NM6Hh)96swafLswOYM)NH_H11)NM`B54B}IaQb@p>w^wo=Cnr5h^rlx{4 zXqp)$qz?+urq^b=y@=3q=@My`h#+yJ$Dead-_`6R7^aP<^QkCdj-rl0JekrkLACA$ z$+wRKc9z7bq|lDy@4^on2Q!9aubV626&Z=XXAX+0k_Ca7E6GkPg+!Z(B$8N>ei>WZ zfU~4hE6bfo8jT5^OUSt+5v0o1{X56g6R5>0lD`+h9z!&=YqfWs;SlXZ_JxhR-rPZ! zUbqT_sen1-OD?U@LUb9CK-W+@X^v#7%s!tJr`u0gJO-YoBXrvH`9ogUzqf|A*J*TN zMVAbzvxuPgG2rvV4FuC86lNg+?{M0FTvUZmrBDbJf}aVJyBUFHr&&a1F&q;q8_Of< zZ*GT{DvDvm$-t5d@akN+N#h9#+-1hF)62^G{CgZwFw{s z;I73{+-u*IQssYvXSL&o*(bot2*sr$}CTX-JS#)5MU{ zZMzj|N!kIwZKIkdyhuKj_f-m2(V5aFMcgV_l_5dc!K?+l^Fs=0NjqsRfJZaQionpy zB$Pzal~Zkiw(DvSvyVD4nyX5aPH|9HQAdbkl2dMi6MBdx1%1*6qTtx;#)%Z_u*RWK zV+v|!cxWSPTIE&pmhQKr$$1O#lAl=ZdY$>o9ZvmHU!qf zgi{__YL7lzcp>?SzGrhZY6F*%5FdE^Ez7!^ZKF5}U$ofm78g}ROG$WQk;#?5$=+{k zpBw4MU{m_kk+N#WzYToKkw=SR_^nJWEd*aN5kvZ96IMvOUw45&WP5l6-*$*7BLOry z+*fB(PTC#65n7`CFv^azG9+1sg{>x*{S8I!al+lpN&Mo!#rcXl-&Owrk|Yh9zDB6Z zvk-dRH6d`&r6bNEXuxD6%yX^ApMND}HKkP%E$O6mbtbB6gkpo`>86!UOB6R%(`|v& z_zpg%u$oRDQjRpg#ByzYNW%jVD=VUkj;g~>^Ez~@*+b9Kzsko}kQ;o<}XoQB0-unWP{4LKX?G>lgN~tM| zL-LiWO2DBg@w!Re-OCT*$C?z0&9xqxo>r2LBJ7Cdk!yR`Hu|{Yg**tDrA`e(V->8+ z{*>#wC1Gs?i;-c(`i~k<7{RYBP4gmBhAoe<+?$dJH}LlJRkETfs}Z1S>Tx&!04hjO z6kGyVc^3MK|L!0R<trt`b0@_DOV=}lyDvn;dj(Gm4g zv>P|ahDf;^0Te{_u~d=`B{F6=B`J!6o{C16p@cHZ$Vm`y4`sK(fw<$Z3}&0R1W>7% zaXP_A1{sCirRk1Nrtaq6Z3l7G|QN+n?Ow#16&;qm-v*#LW1`;IolSdIUeW0sv zxD#$HN$^oyqFjSRo^Qz0;W=jr#i`uMO0Y*AQ?1H~L+mnNy}h3caU)kCsDn!#Y-tn@ z&xKDQk!3?P61SC2Q5L9F+upUiYsH~lCXlJIjS98d>I{n}8q}37HFaz>&l=K`=0P$5 zLGZHxFQ*Wy%f3kjVM|edSt%(nXxHR!x>0o_1+2@Nj+{0(3_@9`>I#Lefm99gFJQ`b zXvc@VJU|Ftm>U(>l*7lA^ouFHIhnLQzKF@B6 zLdRdqzyH&&zgb__&r`Wq2gq4x3yUaKP*p*h7F^>x!5wULl07?!OhJJt&tvrR9o-vb zWzH#TI=Er_)W5ui%jAaAk~rg4k&pT(>!tw|RS{+k5F(KC96qW^Ku+P>$)NGz-rIVu z6ul%F^q`yjsd$mAhpi(pu7F}0a=M>6bu$!PV=J?~(O|hS$u({-Bp+%ex{odd?=;4QDMM%q3gDb>P>76=|a7-GSY^jC{+(xn(=<@Xr9|QcI4Kj-;ML>3< z4#T-Ro03lo8MH1h#9&Z`R~_3@k&i&4b6tRDOlK0Q#4#ykp0csL%tOwnt1PlO2Eyn? zwCp${X-%OpC^)vBS&|JoQ*_5MO8$7K5r1zAS-Qe@-C?Cry6db zW}FvuG)Y*pNwmRCvpbSVBEx5hIv!BpHyd%SCogq4#M9u)xsEk>h7US19%9Bk%G@4U?QhJ#~63d9> zYQgfpPn}ULGaDktv5f-%0EKwUuUNoq6!6RLK%VT81=8Np=nH5yoToC{ohnR9_Q!%PYzJD*()Kf-? z^t4GwRF2?2;j|P3x#rruWe4sRcXF$ea7i?%$#h*ppjv8&$(Vvo68SXJM-<>Q1PIFD z4OD@s;}5-VaMUSPwT;q1B?gz-?ry1PmcN#$MjvZ8joZ~e0wR6dam}iEn8j1iQoNWpUkm1l96+Ru07l+#;?h!~0v(xt1 zt0}W4GdnU+#{)CF+Nk5->Wi=^9RLHR}fhxVhz4-U%*)fQuiOTLL z?KG$Uqi6h240MADsNE{Yfz1tC#UX{YKVTDmJaxAlUGqTw!kzq+#zuol*6D9l@XS^z zXTho^TuIgmF$k$AD22(gmHR*)qh34t_DK7wC-UorC>vhP)nQfN z=&dtS)EML3KGCowt;ZTo`yDi( zTN@p8=KlbkTay!8Z+EVN2SJZ2RwqRB)pRu}=hC4zl6R(pvQmmvkVpxjHt+EqVL8(% z#+8lRxlow+*Bm#cJweL&O?4zVbX7i7&sK4uv+sW~6*i=7y8VNw@Z-ZZWk+bFqbYr% zicMkursrykI;drh;f6*pQ5sUsv=E{7AxIi~d2w>rO*Q#9c10L}MOc0#hi9zy4P_JI zv~=*{?F96J!=1Q`K83&sy|ni5FTMIy$}z@%Mul6F(vbS(VIMI@PuHF+Sy_{C=xQRB zX((}wC?Tm}#oAcvnTgw`mIHiLQ_-v>&q!0Y)MrKbLGwW*_yp`d4xOkP`g zb}}&?ya+s$bpcTl*K$1@CIMJtj28krU{_&1g`2|Tjwdl_e-NfW zm0TG&0+gqX<6AP~h2PK4n_LQHf>xx_QfqVvtil)&er7+i!gh`Bml&C}5#m zZ!Wn>#U^R;8eGj?T~k*_gwE1DQc_B(MD1esyZ0K7HmioC6$*S=zD#K}jjZXObDt23 zvUqFiu_OLYnQ-|A@`m7CwY)zrJe<*hoD?Y{vRj#*CTaRUn{^}0idsCeS5a4Myh%!T zsP;9EoT1FvkGNCG$}VT@G_I!UuTtpZih7KJT-bru8is+}YO||YsyAXZ*NlHMxBi&+ z)59u%ZiDQm3hal~j8U-)iY%p5Wn&vh9V-DF70?}f>Bn2lZGjS@?WFJJ*9Z6yvXZnJ zFRIn`6a1D*s;q22Mfu6F=$ceM@m}`>Ufgxt`+Oxrs?~$@8V|CXu-uQGGS)AO{{S$` z_3>2Vtj#o4bZiPU-F?#=8`}KZvj&_PC}B+us^PVLri9EX^F|dX$-HPPQYJ?^-E|1l9ilF7Q?uQiBrAxZNE^1yybi)vrq@&%<3TQY#is184vs z=sD!+Rsh!0yUXu+J_NpC?!`U(i9%-9VSG(XF7)Uef3ua>_x08l|tqfl?4UuPHhM^@TM<=2J+ zX_kXNr3GyzRc>DXVIChml_^aiWm`Lz*iP0Y3-RS!6%DkRtK}qYlUOlK(}3c2km9uY zTjZ+gQ%dhG(1v;Lg%_dP?sV*4OQ$tDot!oTY7XY=( z0M`KD_;SCO0d=(8s3Hv^ixEQ%aAB@ijyBlgWDIm7_8<=*4l2?C+l@BkgzOZC#V|&$ zt%neuWu%6iSSi*m2974AP#p9y>Z-~-5;#hT3MNdtM(yFR4iW{gh zf$uV|x^5kh0r{3&+<1{O@1e$7o1*Cj4o0!>{b;at52hHN0h<=CfqGmEl3&9nt*roH3~>@JwQh5c#v@ly{t+<^KT6 z1_|~^9r)wf+f61;5mrV->&FT>-j?tz{{YcUV-w36&kQwG)%EFBhs%fVXc|dYD3L^r z0K4r0eYYG6?>nvL422;;8WV27a>3G-q>yX>)BqMNyH%X<@l%6TQ+(7ubrvUD3z_N5 z$0Wie0_vp7g!_K0atto143ksiZ3Q|2`>Qvp9Jx`D@aeHkBLSB@$6HAqeGUPZ7j%_m zi|uA&zEmgyGBH2ujZYKq(#6A)Oj5n%Nnsj5)JH{El{Zc^W`D$@&Qw)(mDq-9q>7%l zhNd$eB|Ho~sH3M#0SpE<3$S-S_564{R$$u$K|3e_-HP5(QbfqA$jm)Z$1=Wg&6spB zR_wwnDzMmTsnS#a^U7jWw0`LOHV3x{Ojspo1Rb;sUS_m7QyUF8R{DU>6>%@g<@{2V zvE8L0a>4SQX&eR2@{;p${(lOkuV3qCd19FpZhbp|0 zCu*_vr;(noigEOz7<#zPsUO0{;M)6O54{ec1ZdhVdw$ zwmp>S{;e~7(q3Mi=6dKD4Ycz@;dCUM6pv7E+m#tIWA7gNy0fwl2{iXZ>dP~!Qx`<@ zD>9X6jT}`9E#aU|b>%;jr2haI_tULs#y->TteDTMEW=tO-OucU3Rra5CCua3eou{)?&9fnu{4UaFJ{^*X?F*yluTkmM(b^af&nAA)NRTQav!s=3Vi8YEZRlQxpCa9vU$r!Blb0xgW z$Pz~$=(&xbOOGF;j+}vwp;Vb$$nk(v@Tl>6#_G)rr8F20F}H7*43kqr`;?ml?${Bf z?Z@7b>3wB&&N=F9qRP0&CV~D{rKqHdqt@p@H5voTySvONebk|y z>wFoC&OKjslB%ezSq~VBXC_#wu&OmsjcZ&3e{W;Tqj%Xz`>W3HUBcBdP4DV|udP_Y zGNx=vEpJV891<1UqYi>9WGQ`a7T32IBPV4d0{%3KS=->^ znD$p1ey?>V0U2JKW-8Le`9~5+<{QAZhW72ozmqa{EPLt1Zw1dsKH660p0V{pp~$4l zSdJRA1_3ImPy{FZ0{!l7@#mM4+mVW?hxd~27)Q8%G~Xt9>MkLR%}t46nB)|!yZ&%H z2;?L80;>xf>C68BFJvbI4JS@@aH1p;&z&gc>Lz!?XkJ_s0>*JUn$bNpo?@+-+}O01 zRvb)nrqppFmW=h_JR)jMA5*%qQBPHejGc-Vg<_IpHBcc-p9Xdsj^y&gC2D@*NtL}1 zKmi1gN=Vi97pe7Z&iOkT^I_VuB|U1Q*ysxdU^fx3E&QdJ`-MIIrMM(`2=;z8j}YqD zS0ST%Df)GeRKXm_->0pO-5+g>U(EXic=Jigt!8x&eJbO5ZWNs)9(`(VJDz%}fh9CF z*;5$Iv{fi1j;92~5t$sXypnEkbR$m#%{7#;t)vRNw}RmVk3O`=Pt*>r%M;W`(wxI8 zC}w7wzB>R4_6AX|y||%SOCbHj*-ec3)f0iJ&z!o$h%~WNbh9whD*`1k)kK@DcM!+U zu^e?7Yd_Ky!t-}jBqY(c^mm-ITzKYok2K*Gc~z&Rqo>1`y~Og!&{Y{^Z_%@D&6D4=(~qwhQ@ z-8(%uC!~rp-mA{?)DhEE*XHM1iu#!F?4Mg!T1PPoc~;U~k+=pT*Y9pgf0IA}l|@GA zyk4Rp*JiJ%P{b9o4lL!5kdGY8W^UFuU~YY!(Xwy)LX>|oa10V@PnK)*twm!}Vp&rZ zz-Z%1B&n;GZqB1bDy@Hd)*NAWO~%k`LosrAidI$6n`x<%Y$pxHu`1+bXlW3&IAh$9 zWRlhc!1v<`vuKet{{Zs`0NYQEn7Y}E(R{o;GpmvdBeb*=Lb5Mw8;LGEYo|5*y@9nt zoK|&myfhz5;%NG_K!&njp5rx&pgY6!X&2{T`A2CEkh@iCBzqNGo25)DHr(h zugTky_a;2QN_iQx$UkZJ(u$gHzQG)F)O2GWcR{wEX2fB-zUzV)%s01>6DrQwhzm_P zoZ{p92AhHF#YD!bdM%DgG_Sn0bH)bi?z!6fanH(H#A_V-SCN|BOz1T>Y{%*fO5Y+* zjpL792H1R&Q?&cQTEH+G-?-x`u(bpGp!fb1ty#^*T;&6cGl#g1|lP zuP&QwP#`Hh`cp1u*FVICbL&nSaxSxC6+T6FM#SjiQpP2kyvoeuZPcdlMZrGx`DHU~ zHV}F8rkTthCt>!`iAx@7!>MbAEz{bm6znT6^Es%Jn1DlH$#&ewLKle5vI!9sq+Yl< z8cV({)TpLk<-It>>**&@(Bss&&FSFWWT`<=!axQc{x|>S>bjWVvXO?Nd-5 zvu>c30?uqrzN=e`e=LEuRE>F~r}$60oW@}4gn~)xvSUh+#v~W5h_3Q4vru)vhc>Hb zzosh3F?0jqKI-E&er)|5wK)nlGYhaxUYIhQ+ulM4eF)`6x<9A!uOi{Xa6zopwOPGb zv^_ra;Xh(HaY#X82i!-6$HSE@C;DUGUN>q^)E{+alM&CpOQjc2;X=$zsU|N2Ftvs6 zeLItGIGZqkinMbgL})(h&n8^!Rw)cKQFOU68cD96ejSU`vaE^$WosP`m~y?tVB)&k zZk$lT2i;9I89S_0q!;N62}O<97lnmZf<=X|ZdMyl@l9!JaYyZ@Y(Fh#46B{;O*3J8etR3jXlg5J>O@Nf zQr5<=Aax{rpzF&#l&!PJ3TX;cZX|5RkM=2)Dk|Qxrn-is9ihZQrGknBxS5n)UI(!o zzy&s&1_WQQw0dqdmDz z6lNelu#c!QX0_>8iwY6mGJ@)G<6r;P2G=rTcy&$}m?^TH^pnwQlsF;UwM zoACr+FTD*^l3j=gK_`XJ3sb(AN*g{Dsol`E7=ARmqWm|ySwPXUV^!5Iq$3)Ni5BAD zXl?9$qn3MoE(Q}%+irESAHI~>f8phjF}Z5#;aTCHo)K3{^;K@-W>TxR!%zyF{4K;P z-mA2yZ92Wzw44XNr%C8*B2t4LEOQ9MG6MCFe!|+1XO9)LpT2gQME35m0mB;g7oog? z0-;k{B?Xxp3__ts@^@=(K;!Ob?*W0Tx4W%IIMy6j(I!QxsuN8$Pr3!;mk^YfBTEv0 zk1WP~838eRxO50i8VX#K$[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/08-colors-basic-light/resources/textures/popcorn.jpg b/08-colors-basic-light/resources/textures/popcorn.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f82106f468a6c55a285390b2603c58bafc6df8d GIT binary patch literal 6006 zcmeHHNlX+$6#doJ+w>4a!wf1OWYv)vGCjkv%!L4gK*R{*dK*-9JeYteXkr4mpq>Ob z^aQwo-cZ5iU_f!>hAZI3an}>LOQP+s2El^|^=Rr>>euV4|11AhRX=mkd;;Nxc?Eeu z2!VWTV20p(ZcVTppr{Cv06+yh0icM8P>YUC;Aw2a!fdUH$m8=M;JkAJ;|hreiREH% zCbK4S3vvAtZ?G)D9ifAGEbKts-4Fy3N0!@OE$pc zHoSg!y5F4|V`TV!Y5o*9R(}9M!5q=;@fa<_&s_y*p;H*w(agt?0|FigAVod`hus2`k3v9k>pnE=9x|S#o4?K#8kxcEJz3;}&Tet7@-@SML!NW&`L&Kq`&z`?{`RetXx1;agfB5+6^Ovtd0mIAy-1Kgj@-^ f5^^QvO30OvD>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/08-colors-basic-light/scripts/windows_setup.ps1 b/08-colors-basic-light/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/08-colors-basic-light/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/08-colors-basic-light/shaders/08-frag.glsl b/08-colors-basic-light/shaders/08-frag.glsl new file mode 100644 index 0000000..fbb5577 --- /dev/null +++ b/08-colors-basic-light/shaders/08-frag.glsl @@ -0,0 +1,26 @@ +#version 330 core + +out vec4 FragColor; +in vec3 FragPos; +in vec2 TexCoord; +in vec3 Normal; + +uniform sampler2D texture1; +uniform vec3 objectColor; +uniform vec3 lightColor; +uniform vec3 lightPos; + +void main() +{ + float ambientStrength = 0.2; + vec3 ambient = ambientStrength * lightColor; + + vec3 norm = normalize(Normal); + vec3 lightDir = normalize(lightPos - FragPos); + + float diff = max(dot(norm, lightDir), 0.0); + vec3 diffuse = diff * lightColor; + + vec3 result = ambient + diffuse; + FragColor = texture(texture1, TexCoord) * vec4(result, 1.0); +} diff --git a/08-colors-basic-light/shaders/08-lightsource.frag.glsl b/08-colors-basic-light/shaders/08-lightsource.frag.glsl new file mode 100644 index 0000000..6b1b351 --- /dev/null +++ b/08-colors-basic-light/shaders/08-lightsource.frag.glsl @@ -0,0 +1,7 @@ +#version 330 core +out vec4 FragColor; + +void main() +{ + FragColor = vec4(1.0); // set all 4 vector values to 1.0 +} diff --git a/08-colors-basic-light/shaders/08-vert.glsl b/08-colors-basic-light/shaders/08-vert.glsl new file mode 100644 index 0000000..62a3d0e --- /dev/null +++ b/08-colors-basic-light/shaders/08-vert.glsl @@ -0,0 +1,22 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; +layout (location = 2) in vec2 aTexCoord; + +out vec2 TexCoord; +out vec3 FragPos; +out vec3 Normal; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + FragPos = vec3(model * vec4(aPos, 1.0)); + + Normal = mat3(transpose(inverse(model))) * aNormal; + + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/08-colors-basic-light/shaders/3.3.shader.fs b/08-colors-basic-light/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/08-colors-basic-light/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/08-colors-basic-light/shaders/3.3.shader.vs b/08-colors-basic-light/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/08-colors-basic-light/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/08-colors-basic-light/shaders/4.2.texture.fs b/08-colors-basic-light/shaders/4.2.texture.fs new file mode 100644 index 0000000..80ee6a7 --- /dev/null +++ b/08-colors-basic-light/shaders/4.2.texture.fs @@ -0,0 +1,11 @@ +#version 330 core + +out vec4 FragColor; +in vec2 TexCoord; + +uniform sampler2D texture1; + +void main() +{ + FragColor = texture(texture1, TexCoord); +} diff --git a/08-colors-basic-light/shaders/4.2.texture.vs b/08-colors-basic-light/shaders/4.2.texture.vs new file mode 100644 index 0000000..85c9de7 --- /dev/null +++ b/08-colors-basic-light/shaders/4.2.texture.vs @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTexCoord; + +out vec2 TexCoord; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/08-colors-basic-light/src/camera.cpp b/08-colors-basic-light/src/camera.cpp new file mode 100644 index 0000000..d27e61d --- /dev/null +++ b/08-colors-basic-light/src/camera.cpp @@ -0,0 +1,63 @@ +#include "camera.hpp" +#include +#include + +glm::mat4 Camera::lookAt() { + return glm::lookAt(pos, pos + front, up); +} + +void Camera::forward() { + pos += speed * front; +} + +void Camera::back() { + pos -= speed * front; +} + +void Camera::left() { + pos -= glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::right() { + pos += glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::update(float deltaTime) { + speed = 2.5f * deltaTime; +} + +void Camera::mouse_move(double xpos, double ypos) { + if(firstMouse) { + lastX = xpos; + lastY = ypos; + firstMouse = false; + } + + float xoffset = xpos - lastX; + float yoffset = lastY - ypos; + lastX = xpos; + lastY = ypos; + + const float sensitivity = 0.1f; + xoffset *= sensitivity; + yoffset *= sensitivity; + + yaw += xoffset; + pitch += yoffset; + + if(pitch > 89.0f) pitch = 89.0f; + if(pitch < -89.0f) pitch = -89.0f; + + direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); + direction.y = sin(glm::radians(pitch)); + direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); + + front = glm::normalize(direction); +} + +void Camera::mouse_scroll(double xoffset, double yoffset) { + fov -= (float)yoffset; + + if(fov < 1.0f) fov = 1.0f; + if(fov > 90.0f) fov = 90.0f; +} diff --git a/08-colors-basic-light/src/camera.hpp b/08-colors-basic-light/src/camera.hpp new file mode 100644 index 0000000..46f082b --- /dev/null +++ b/08-colors-basic-light/src/camera.hpp @@ -0,0 +1,26 @@ +#pragma once +#include + +struct Camera { + glm::vec3 pos = glm::vec3(0.0f, 0.0f, 3.0f); + glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f); + glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f); + glm::vec3 direction = glm::vec3(0.0f, 0.0f, 0.0f); + + float pitch = 0.0f; + float yaw = -90.0f; + float speed = 0.05f; + float lastX = 400; + float lastY = 300; + float fov = 45.0f; + bool firstMouse = true; + + glm::mat4 lookAt(); + void forward(); + void back(); + void left(); + void right(); + void update(float deltaTime); + void mouse_move(double xpos, double ypos); + void mouse_scroll(double xoffset, double yoffset); +}; diff --git a/08-colors-basic-light/src/data.hpp b/08-colors-basic-light/src/data.hpp new file mode 100644 index 0000000..519bf14 --- /dev/null +++ b/08-colors-basic-light/src/data.hpp @@ -0,0 +1,46 @@ +#pragma once +#include + +float light_source_verts[] = { + -0.5f, -0.5f, -0.5f, + 0.5f, -0.5f, -0.5f, + 0.5f, 0.5f, -0.5f, + 0.5f, 0.5f, -0.5f, + -0.5f, 0.5f, -0.5f, + -0.5f, -0.5f, -0.5f, + + -0.5f, -0.5f, 0.5f, + 0.5f, -0.5f, 0.5f, + 0.5f, 0.5f, 0.5f, + 0.5f, 0.5f, 0.5f, + -0.5f, 0.5f, 0.5f, + -0.5f, -0.5f, 0.5f, + + -0.5f, 0.5f, 0.5f, + -0.5f, 0.5f, -0.5f, + -0.5f, -0.5f, -0.5f, + -0.5f, -0.5f, -0.5f, + -0.5f, -0.5f, 0.5f, + -0.5f, 0.5f, 0.5f, + + 0.5f, 0.5f, 0.5f, + 0.5f, 0.5f, -0.5f, + 0.5f, -0.5f, -0.5f, + 0.5f, -0.5f, -0.5f, + 0.5f, -0.5f, 0.5f, + 0.5f, 0.5f, 0.5f, + + -0.5f, -0.5f, -0.5f, + 0.5f, -0.5f, -0.5f, + 0.5f, -0.5f, 0.5f, + 0.5f, -0.5f, 0.5f, + -0.5f, -0.5f, 0.5f, + -0.5f, -0.5f, -0.5f, + + -0.5f, 0.5f, -0.5f, + 0.5f, 0.5f, -0.5f, + 0.5f, 0.5f, 0.5f, + 0.5f, 0.5f, 0.5f, + -0.5f, 0.5f, 0.5f, + -0.5f, 0.5f, -0.5f, +}; diff --git a/08-colors-basic-light/src/dbc.cpp b/08-colors-basic-light/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/08-colors-basic-light/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/08-colors-basic-light/src/dbc.hpp b/08-colors-basic-light/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/08-colors-basic-light/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/08-colors-basic-light/src/main.cpp b/08-colors-basic-light/src/main.cpp new file mode 100644 index 0000000..62be021 --- /dev/null +++ b/08-colors-basic-light/src/main.cpp @@ -0,0 +1,282 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include "data.hpp" +#include "physics.hpp" +#include "model.hpp" +#include "camera.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + Shader shader; + Shader light; + Model model; + glm::vec3 lightPos{1.2f, 1.0f, 2.0f}; + unsigned int lightCubeVAO = 0; + unsigned int VBO = 0; + unsigned int texture1 = 0; + Camera camera{}; + float deltaTime = 0.0f; + float lastFrame = 0.0f; + + + void updateDelta() { + float currentFrame = glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; + } +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +void mouse_callback(GLFWwindow *window, double xpos, double ypos) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_move(xpos, ypos); +} + +void scroll_callback(GLFWwindow *window, double xoffset, double yoffset) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_scroll(xoffset, yoffset); +} + + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); + glfwSetCursorPosCallback(window, mouse_callback); + glfwSetScrollCallback(window, scroll_callback); + + return window; +} + + +void processInput(GLFWwindow *window, BoxTest &box, Camera& camera) { + + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + for(size_t i = 0; i < BODY_COUNT; i++) { + box.bodies[i]->ApplyForceToCenter(force, true); + box.bodies[i]->ApplyTorque(0.1f, true); + } + } + + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { + camera.forward(); + } + + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { + camera.back(); + } + + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { + camera.left(); + } + + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { + camera.right(); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + glEnable(GL_DEPTH_TEST); + + Config config{ + .shader={"shaders/08-vert.glsl", "shaders/08-frag.glsl"}, + .light={"shaders/08-vert.glsl", "shaders/08-lightsource.frag.glsl"}, + .model={"assets/popcorn_model_a.glb"} + }; + + unsigned int VBO = 0; + unsigned int lightCubeVAO = 0; + + glGenVertexArrays(1, &lightCubeVAO); + glGenBuffers(1, &VBO); + + glBindVertexArray(lightCubeVAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(light_source_verts), light_source_verts, GL_STATIC_DRAW); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + config.texture1 = load_texture("resources/textures/popcorn.jpg"); + + config.shader.use(); + config.shader.setInt("texture1", 0); + config.shader.setVec3("objectColor", 1.0f, 0.5f, 0.31f); + config.shader.setVec3("lightColor", 1.0f, 1.0f, 1.0f); + + config.lightCubeVAO = lightCubeVAO; + config.VBO = VBO; + + return config; +} + +void draw_light(Config& config, glm::mat4& projection, glm::mat4& view) { + config.light.use(); + // BUG: is this wrong?Make a vec3 that takes glm::vec3 + + config.light.setVec3("lightPos", config.lightPos); + config.light.setMat4("projection", projection); + config.light.setMat4("view", view); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, config.lightPos); + model = glm::scale(model, glm::vec3(0.2f)); + config.light.setMat4("model", model); + + glBindVertexArray(config.lightCubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); +} + +void render(GLFWwindow* window, Config& config, BoxTest& box, b2World& world) { + glClearColor(0.2f, 0.3f, 0.3f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, config.texture1); + + config.shader.use(); + + Box2d_step_world(world); + + // time is used for fake 3d rotation + float time = glfwGetTime(); + + config.camera.update(config.deltaTime); + glm::mat4 view = config.camera.lookAt(); + + config.shader.setMat4("view", view); + + glm::mat4 projection = glm::mat4(1.0f); + // fov, aspect, near plane, far plane + projection = glm::perspective(glm::radians(config.camera.fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); + config.shader.setMat4("projection", projection); + + glBindVertexArray(config.lightCubeVAO); + + // render the loaded model + glm::mat4 model = glm::mat4(1.0f); + + // get position from box + b2Vec2 position = box.bodies[0]->GetPosition(); + float angle = box.bodies[0]->GetAngle(); + + model = glm::translate(model, glm::vec3(position.x, position.y, 0.0f)); + + model = glm::rotate(model, angle / 5.0f, glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(time * 10.0f), glm::vec3(0.0f, 1.0f, 1.0f)); + model = glm::scale(model, glm::vec3(0.5f, 0.5f, 0.5f)); // it's a bit too big for our scene, so scale it down + config.shader.setMat4("model", model); + config.model.Draw(config.shader); + + draw_light(config, projection, view); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.VBO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + auto config = setup(); + + glfwSetWindowUserPointer(window, &config.camera); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box, config.camera); + render(window, config, box, world); + config.updateDelta(); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/08-colors-basic-light/src/mesh.cpp b/08-colors-basic-light/src/mesh.cpp new file mode 100644 index 0000000..a05e18b --- /dev/null +++ b/08-colors-basic-light/src/mesh.cpp @@ -0,0 +1,57 @@ +#include "mesh.hpp" + +void Mesh::Draw(Shader &shader) { + unsigned int diffuseNr = 1; + unsigned int specularNr = 1; + unsigned int normalNr = 1; + unsigned int heightNr = 1; + + for(unsigned int i = 0; i < textures.size(); i++) { + glActiveTexture(GL_TEXTURE0 + i); + std::string number; + std::string name = textures[i].type; + + if(name == "texture_diffuse") { + number = std::to_string(diffuseNr++); + } else if(name == "texture_specular") { + number = std::to_string(specularNr++); + } else if(name == "texture_normal") { + number = std::to_string(normalNr++); + } else if(name == "texture_height") { + number = std::to_string(heightNr++); + } + + // TODO: Get this uniform ID once and cache it? + glUniform1i(glGetUniformLocation(shader.ID, (name + number).c_str()), i); + glBindTexture(GL_TEXTURE_2D, textures[i].id); + } + + glBindVertexArray(VAO); + glDrawElements(GL_TRIANGLES, static_cast(indices.size()), GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + + glActiveTexture(GL_TEXTURE0); +} + + +void Mesh::setupMesh() { + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Position)); + + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal)); + + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords)); +} diff --git a/08-colors-basic-light/src/mesh.hpp b/08-colors-basic-light/src/mesh.hpp new file mode 100644 index 0000000..50b515d --- /dev/null +++ b/08-colors-basic-light/src/mesh.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +#include "shader.hpp" + +#include +#include + +struct Vertex { + glm::vec3 Position; + glm::vec3 Normal; + glm::vec2 TexCoords; +}; + +struct Texture { + unsigned int id; + std::string type; + std::string path; +}; + +struct Mesh { + std::vector vertices; + std::vector indices; + std::vector textures; + unsigned int VAO; + unsigned int VBO; + unsigned int EBO; + + Mesh(std::vector vertices, std::vector indices, std::vector textures) : + vertices(vertices), + indices(indices), + textures(textures) + { + setupMesh(); + } + + void Draw(Shader &shader); + void setupMesh(); +}; diff --git a/08-colors-basic-light/src/model.cpp b/08-colors-basic-light/src/model.cpp new file mode 100644 index 0000000..e6b2fdd --- /dev/null +++ b/08-colors-basic-light/src/model.cpp @@ -0,0 +1,171 @@ +#include "model.hpp" +#include "dbc.hpp" + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma) +{ + std::string filename = path + "/" + filename; + + unsigned int textureID; + glGenTextures(1, &textureID); + + int width = 0; + int height = 0; + int nrComponents = 0; + + unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0); + dbc::check(data != nullptr, $F("Failed to load texture {}", filename)); + + GLenum format = GL_RGB; + + if (nrComponents == 1) { + format = GL_RED; + } else if (nrComponents == 3) { + format = GL_RGB; + } else if (nrComponents == 4) { + format = GL_RGBA; + } + + glBindTexture(GL_TEXTURE_2D, textureID); + glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + stbi_image_free(data); + + return textureID; +} + +void Model::Draw(Shader &shader) { + for(unsigned int i = 0; i < meshes.size(); i++) { + meshes[i].Draw(shader); + } +} + +void Model::loadModel(std::string path) { + Assimp::Importer importer; + const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); + + dbc::check(scene != nullptr, "Assimp ReadFile return null"); + dbc::check(!(scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE), "Assimp says incomplete."); + dbc::check(scene->mRootNode != nullptr, "Assimp loaded scene doesn't have a root node"); + + directory = path.substr(0, path.find_last_of('/')); + + processNode(scene->mRootNode, scene); +} + +void Model::processNode(aiNode *node, const aiScene *scene) { + for(unsigned int i = 0; i < node->mNumMeshes; i++) { + aiMesh* mesh = scene->mMeshes[node->mMeshes[i]]; + meshes.push_back(processMesh(mesh, scene)); + } + + for(unsigned int i = 0; i < node->mNumChildren; i++) { + processNode(node->mChildren[i], scene); + } +} + +Mesh Model::processMesh(aiMesh *mesh, const aiScene *scene) { + std::vector vertices; + std::vector indices; + std::vector textures; + + for(unsigned int i = 0; i < mesh->mNumVertices; i++) { + Vertex vertex; + vertex.Position = glm::vec3( + mesh->mVertices[i].x, + mesh->mVertices[i].y, + mesh->mVertices[i].z); + + if(mesh->HasNormals()) { + vertex.Normal = glm::vec3( + mesh->mNormals[i].x, + mesh->mNormals[i].y, + mesh->mNormals[i].z); + } + + if(mesh->mTextureCoords[0]) { + vertex.TexCoords = glm::vec2( + mesh->mTextureCoords[0][i].x, + mesh->mTextureCoords[0][i].y + ); + } else { + vertex.TexCoords = glm::vec2(0.0f, 0.0f); + } + + vertices.push_back(vertex); + } + + for(unsigned int i = 0; i < mesh->mNumFaces; i++) { + aiFace face = mesh->mFaces[i]; + + for(unsigned int j = 0; j < face.mNumIndices; j++) { + indices.push_back(face.mIndices[j]); + } + } + + aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex]; + + // we assume a convention for sampler names in the shaders. Each diffuse texture should be named + // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. + // Same applies to other texture as the following list summarizes: + // diffuse: texture_diffuseN + // specular: texture_specularN + // normal: texture_normalN + + // 1. diffuse maps + std::vector diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse"); + textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); + + // 2. specular maps + std::vector specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular"); + textures.insert(textures.end(), specularMaps.begin(), specularMaps.end()); + + // 3. normal maps + std::vector normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal"); + textures.insert(textures.end(), normalMaps.begin(), normalMaps.end()); + + // 4. height maps + std::vector heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height"); + textures.insert(textures.end(), heightMaps.begin(), heightMaps.end()); + + return Mesh(vertices, indices, textures); +} + +std::vector Model::loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName) +{ + fmt::println("TEXTURE COUNT: {}, {}, {}", (int)type, typeName, mat->GetTextureCount(type)); + + std::vector textures; + for(unsigned int i = 0; i < mat->GetTextureCount(type); i++) { + aiString str; + mat->GetTexture(type, i, &str); + std::string tx_str{str.C_Str()}; + + bool skip = false; + for(unsigned int j = 0; j < textures_loaded.size(); j++) { + if(textures_loaded[j].path == tx_str) { + textures.push_back(textures_loaded[j]); + skip = true; + break; + } + } + + if(!skip) { + Texture texture{ + .id = TextureFromFile(tx_str, directory), + .type = typeName, + .path = tx_str, + }; + + textures.push_back(texture); + textures_loaded.push_back(texture); + } + } + + return textures; +} diff --git a/08-colors-basic-light/src/model.hpp b/08-colors-basic-light/src/model.hpp new file mode 100644 index 0000000..8d23203 --- /dev/null +++ b/08-colors-basic-light/src/model.hpp @@ -0,0 +1,40 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma = false); + +struct Model { + std::vector textures_loaded; + std::vector meshes; + std::string directory; + bool gammaCorrection; + + Model(const char *path) { + loadModel(path); + } + + void Draw(Shader &shader); + + void loadModel(std::string path); + void processNode(aiNode *node, const aiScene *scene); + Mesh processMesh(aiMesh *mesh, const aiScene *scene); + + std::vector loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName); +}; diff --git a/08-colors-basic-light/src/physics.cpp b/08-colors-basic-light/src/physics.cpp new file mode 100644 index 0000000..daa8f87 --- /dev/null +++ b/08-colors-basic-light/src/physics.cpp @@ -0,0 +1,49 @@ +#include "physics.hpp" + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + for(size_t i = 0; i < BODY_COUNT; i++) { + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.5f); + box.bodies[i] = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.bodies[i]->CreateFixture(&fixtureDef); + } + + return box; +} + +void Box2d_step_world(b2World& world) { + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); +} diff --git a/08-colors-basic-light/src/physics.hpp b/08-colors-basic-light/src/physics.hpp new file mode 100644 index 0000000..dc98a31 --- /dev/null +++ b/08-colors-basic-light/src/physics.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +#define BODY_COUNT 1 + +struct BoxTest { + b2Body *walls[4]; + b2Body *bodies[BODY_COUNT]; +}; + +struct BoxTest Box2d_setup(b2World &world); +void Box2d_step_world(b2World& world); diff --git a/08-colors-basic-light/src/shader.cpp b/08-colors-basic-light/src/shader.cpp new file mode 100644 index 0000000..a89af73 --- /dev/null +++ b/08-colors-basic-light/src/shader.cpp @@ -0,0 +1,126 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" +#include +#include +#include + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} + +void Shader::setVec4(const std::string &name, const glm::vec4& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, const glm::vec3& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, float v1, float v2, float v3) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3f(uniform, v1, v2, v3); +} + +void Shader::setMat4(const std::string &name, const glm::mat4& mat) const { + unsigned int loc = glGetUniformLocation(ID, name.c_str()); + glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(mat)); +} diff --git a/08-colors-basic-light/src/shader.hpp b/08-colors-basic-light/src/shader.hpp new file mode 100644 index 0000000..afa8f05 --- /dev/null +++ b/08-colors-basic-light/src/shader.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void setVec4(const std::string &name, const glm::vec4& value) const; + void setVec3(const std::string &name, float v1, float v2, float v3) const; + void setVec3(const std::string &name, const glm::vec3& value) const; + void setMat4(const std::string &name, const glm::mat4& what) const; + void cleanup(); +}; diff --git a/08-colors-basic-light/src/stb_image.cpp b/08-colors-basic-light/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/08-colors-basic-light/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/08-colors-basic-light/src/stb_image.h b/08-colors-basic-light/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/08-colors-basic-light/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/08-colors-basic-light/tests/bad_shader.vs b/08-colors-basic-light/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/08-colors-basic-light/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/08-colors-basic-light/tests/main.cpp b/08-colors-basic-light/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/08-colors-basic-light/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/08-colors-basic-light/tests/meson.build b/08-colors-basic-light/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/08-colors-basic-light/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/08-colors-basic-light/tests/shader_tests.cpp b/08-colors-basic-light/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/08-colors-basic-light/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/08-colors-basic-light/wraps/assimp.wrap b/08-colors-basic-light/wraps/assimp.wrap new file mode 100644 index 0000000..4bb6029 --- /dev/null +++ b/08-colors-basic-light/wraps/assimp.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=assimp-5.4.3 +url=https://github.com/assimp/assimp.git +revision=v5.4.3 +depth=1 +method=cmake + +[provide] +assimp = assimp_dep diff --git a/08-colors-basic-light/wraps/box2d.wrap b/08-colors-basic-light/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/08-colors-basic-light/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/08-colors-basic-light/wraps/fmt.wrap b/08-colors-basic-light/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/08-colors-basic-light/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/08-colors-basic-light/wraps/fuc2.wrap b/08-colors-basic-light/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/08-colors-basic-light/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/08-colors-basic-light/wraps/glfw.wrap b/08-colors-basic-light/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/08-colors-basic-light/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/08-colors-basic-light/wraps/glm.wrap b/08-colors-basic-light/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/08-colors-basic-light/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep diff --git a/09-basic-light-materials/.gitignore b/09-basic-light-materials/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/09-basic-light-materials/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/09-basic-light-materials/.vimrc_proj b/09-basic-light-materials/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/09-basic-light-materials/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/09-basic-light-materials/KHR/khrplatform.h b/09-basic-light-materials/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/09-basic-light-materials/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/09-basic-light-materials/LICENSE b/09-basic-light-materials/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/09-basic-light-materials/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/09-basic-light-materials/Makefile b/09-basic-light-materials/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/09-basic-light-materials/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/09-basic-light-materials/assets/popcorn_model_a.glb b/09-basic-light-materials/assets/popcorn_model_a.glb new file mode 100644 index 0000000000000000000000000000000000000000..dc02c851484560bbb0cdecd5e1cca2458dce10ea GIT binary patch literal 18016 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 +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/09-basic-light-materials/glad/glad.h b/09-basic-light-materials/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/09-basic-light-materials/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/09-basic-light-materials/meson.build b/09-basic-light-materials/meson.build new file mode 100644 index 0000000..a971022 --- /dev/null +++ b/09-basic-light-materials/meson.build @@ -0,0 +1,100 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +assimp = subproject('assimp').get_variable('assimp_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d, assimp +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', + 'src/physics.cpp', + 'src/mesh.cpp', + 'src/model.cpp', + 'src/camera.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/09-basic-light-materials/resources/textures/awesomeface.png b/09-basic-light-materials/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 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 Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/09-basic-light-materials/resources/textures/container.jpg b/09-basic-light-materials/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys 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[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/09-basic-light-materials/resources/textures/popcorn.jpg b/09-basic-light-materials/resources/textures/popcorn.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f82106f468a6c55a285390b2603c58bafc6df8d GIT binary patch literal 6006 zcmeHHNlX+$6#doJ+w>4a!wf1OWYv)vGCjkv%!L4gK*R{*dK*-9JeYteXkr4mpq>Ob z^aQwo-cZ5iU_f!>hAZI3an}>LOQP+s2El^|^=Rr>>euV4|11AhRX=mkd;;Nxc?Eeu z2!VWTV20p(ZcVTppr{Cv06+yh0icM8P>YUC;Aw2a!fdUH$m8=M;JkAJ;|hreiREH% zCbK4S3vvAtZ?G)D9ifAGEbKts-4Fy3N0!@OE$pc zHoSg!y5F4|V`TV!Y5o*9R(}9M!5q=;@fa<_&s_y*p;H*w(agt?0|FigAVod`hus2`k3v9k>pnE=9x|S#o4?K#8kxcEJz3;}&Tet7@-@SML!NW&`L&Kq`&z`?{`RetXx1;agfB5+6^Ovtd0mIAy-1Kgj@-^ f5^^QvO30OvD>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/09-basic-light-materials/scripts/windows_setup.ps1 b/09-basic-light-materials/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/09-basic-light-materials/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/09-basic-light-materials/shaders/08-frag.glsl b/09-basic-light-materials/shaders/08-frag.glsl new file mode 100644 index 0000000..2f81725 --- /dev/null +++ b/09-basic-light-materials/shaders/08-frag.glsl @@ -0,0 +1,32 @@ +#version 330 core + +out vec4 FragColor; +in vec3 FragPos; +in vec3 Normal; + +uniform vec3 objectColor; +uniform vec3 lightColor; +uniform vec3 lightPos; +uniform vec3 viewPos; + +void main() +{ + float ambientStrength = 0.1; + float specularStrength = 0.5; + vec3 ambient = ambientStrength * lightColor; + + vec3 norm = normalize(Normal); + vec3 lightDir = normalize(lightPos - FragPos); + float diff = max(dot(norm, lightDir), 0.0); + vec3 diffuse = diff * lightColor; + + vec3 viewDir = normalize(viewPos - FragPos); + vec3 reflectDir = reflect(-lightDir, norm); + + float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32); + vec3 specular = specularStrength * spec * lightColor; + + vec3 result = (ambient + diffuse + specular) * objectColor; + + FragColor = vec4(result, 1.0); +} diff --git a/09-basic-light-materials/shaders/08-lightsource.frag.glsl b/09-basic-light-materials/shaders/08-lightsource.frag.glsl new file mode 100644 index 0000000..6b1b351 --- /dev/null +++ b/09-basic-light-materials/shaders/08-lightsource.frag.glsl @@ -0,0 +1,7 @@ +#version 330 core +out vec4 FragColor; + +void main() +{ + FragColor = vec4(1.0); // set all 4 vector values to 1.0 +} diff --git a/09-basic-light-materials/shaders/08-vert.glsl b/09-basic-light-materials/shaders/08-vert.glsl new file mode 100644 index 0000000..eda4400 --- /dev/null +++ b/09-basic-light-materials/shaders/08-vert.glsl @@ -0,0 +1,17 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; + +out vec3 FragPos; +out vec3 Normal; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + FragPos = vec3(model * vec4(aPos, 1.0)); + Normal = mat3(transpose(inverse(model))) * aNormal; +} diff --git a/09-basic-light-materials/shaders/3.3.shader.fs b/09-basic-light-materials/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/09-basic-light-materials/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/09-basic-light-materials/shaders/3.3.shader.vs b/09-basic-light-materials/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/09-basic-light-materials/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/09-basic-light-materials/shaders/4.2.texture.fs b/09-basic-light-materials/shaders/4.2.texture.fs new file mode 100644 index 0000000..80ee6a7 --- /dev/null +++ b/09-basic-light-materials/shaders/4.2.texture.fs @@ -0,0 +1,11 @@ +#version 330 core + +out vec4 FragColor; +in vec2 TexCoord; + +uniform sampler2D texture1; + +void main() +{ + FragColor = texture(texture1, TexCoord); +} diff --git a/09-basic-light-materials/shaders/4.2.texture.vs b/09-basic-light-materials/shaders/4.2.texture.vs new file mode 100644 index 0000000..85c9de7 --- /dev/null +++ b/09-basic-light-materials/shaders/4.2.texture.vs @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTexCoord; + +out vec2 TexCoord; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/09-basic-light-materials/src/camera.cpp b/09-basic-light-materials/src/camera.cpp new file mode 100644 index 0000000..d27e61d --- /dev/null +++ b/09-basic-light-materials/src/camera.cpp @@ -0,0 +1,63 @@ +#include "camera.hpp" +#include +#include + +glm::mat4 Camera::lookAt() { + return glm::lookAt(pos, pos + front, up); +} + +void Camera::forward() { + pos += speed * front; +} + +void Camera::back() { + pos -= speed * front; +} + +void Camera::left() { + pos -= glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::right() { + pos += glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::update(float deltaTime) { + speed = 2.5f * deltaTime; +} + +void Camera::mouse_move(double xpos, double ypos) { + if(firstMouse) { + lastX = xpos; + lastY = ypos; + firstMouse = false; + } + + float xoffset = xpos - lastX; + float yoffset = lastY - ypos; + lastX = xpos; + lastY = ypos; + + const float sensitivity = 0.1f; + xoffset *= sensitivity; + yoffset *= sensitivity; + + yaw += xoffset; + pitch += yoffset; + + if(pitch > 89.0f) pitch = 89.0f; + if(pitch < -89.0f) pitch = -89.0f; + + direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); + direction.y = sin(glm::radians(pitch)); + direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); + + front = glm::normalize(direction); +} + +void Camera::mouse_scroll(double xoffset, double yoffset) { + fov -= (float)yoffset; + + if(fov < 1.0f) fov = 1.0f; + if(fov > 90.0f) fov = 90.0f; +} diff --git a/09-basic-light-materials/src/camera.hpp b/09-basic-light-materials/src/camera.hpp new file mode 100644 index 0000000..46f082b --- /dev/null +++ b/09-basic-light-materials/src/camera.hpp @@ -0,0 +1,26 @@ +#pragma once +#include + +struct Camera { + glm::vec3 pos = glm::vec3(0.0f, 0.0f, 3.0f); + glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f); + glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f); + glm::vec3 direction = glm::vec3(0.0f, 0.0f, 0.0f); + + float pitch = 0.0f; + float yaw = -90.0f; + float speed = 0.05f; + float lastX = 400; + float lastY = 300; + float fov = 45.0f; + bool firstMouse = true; + + glm::mat4 lookAt(); + void forward(); + void back(); + void left(); + void right(); + void update(float deltaTime); + void mouse_move(double xpos, double ypos); + void mouse_scroll(double xoffset, double yoffset); +}; diff --git a/09-basic-light-materials/src/data.hpp b/09-basic-light-materials/src/data.hpp new file mode 100644 index 0000000..83245f2 --- /dev/null +++ b/09-basic-light-materials/src/data.hpp @@ -0,0 +1,46 @@ +#pragma once +#include + +float vertices[] = { + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f +}; diff --git a/09-basic-light-materials/src/dbc.cpp b/09-basic-light-materials/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/09-basic-light-materials/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/09-basic-light-materials/src/dbc.hpp b/09-basic-light-materials/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/09-basic-light-materials/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/09-basic-light-materials/src/main.cpp b/09-basic-light-materials/src/main.cpp new file mode 100644 index 0000000..e6c1b6a --- /dev/null +++ b/09-basic-light-materials/src/main.cpp @@ -0,0 +1,319 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include "data.hpp" +#include "physics.hpp" +#include "model.hpp" +#include "camera.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + Shader shader; + Shader light; + Model model; + glm::vec3 lightPos{1.2f, 1.0f, 2.0f}; + glm::vec3 boxPos{2.0f, 0.0f, 0.0f}; + unsigned int cubeVAO = 0; + unsigned int lightCubeVAO = 0; + unsigned int VBO = 0; + Camera camera{}; + float deltaTime = 0.0f; + float lastFrame = 0.0f; + + void updateDelta() { + float currentFrame = glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; + } +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +void mouse_callback(GLFWwindow *window, double xpos, double ypos) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_move(xpos, ypos); +} + +void scroll_callback(GLFWwindow *window, double xoffset, double yoffset) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_scroll(xoffset, yoffset); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); + glfwSetCursorPosCallback(window, mouse_callback); + glfwSetScrollCallback(window, scroll_callback); + + return window; +} + + +void processInput(GLFWwindow *window, BoxTest &box, Camera& camera) { + + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + for(size_t i = 0; i < BODY_COUNT; i++) { + box.bodies[i]->ApplyForceToCenter(force, true); + box.bodies[i]->ApplyTorque(0.1f, true); + } + } + + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { + camera.forward(); + } + + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { + camera.back(); + } + + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { + camera.left(); + } + + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { + camera.right(); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + glEnable(GL_DEPTH_TEST); + + Config config{ + .shader={"shaders/08-vert.glsl", "shaders/08-frag.glsl"}, + .light={"shaders/08-vert.glsl", "shaders/08-lightsource.frag.glsl"}, + .model={"assets/popcorn_model_a.glb"} + }; + + unsigned int VBO = 0; + unsigned int lightCubeVAO = 0; + unsigned int cubeVAO = 0; + + // cube vao configure, this is the light target + glGenVertexArrays(1, &cubeVAO); + glGenBuffers(1, &VBO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + glBindVertexArray(cubeVAO); + + // position attribute + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + // light vao configure, this is the light source + glGenVertexArrays(1, &lightCubeVAO); + glBindVertexArray(lightCubeVAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + config.lightCubeVAO = lightCubeVAO; + config.cubeVAO = cubeVAO; + config.VBO = VBO; + + return config; +} + +void draw_popcorn(Config& config, BoxTest& box, size_t box_i, glm::mat4& projection, glm::mat4& view) +{ + config.shader.use(); + config.shader.setVec3("objectColor", 1.0f, 0.5f, 0.31f); + config.shader.setVec3("lightColor", 1.0f, 1.0f, 1.0f); + // THIS WAS MISSING + config.shader.setVec3("lightPos", config.lightPos); + + config.shader.setMat4("view", view); + config.shader.setMat4("projection", projection); + config.shader.setVec3("viewPos", config.camera.pos); + + float time = glfwGetTime(); + // get position from box + b2Vec2 position = box.bodies[box_i]->GetPosition(); + float angle = box.bodies[box_i]->GetAngle(); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, glm::vec3(position.x, position.y, 0.0f)); + + model = glm::rotate(model, angle / 5.0f, glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(time * 10.0f), glm::vec3(0.0f, 1.0f, 1.0f)); + + config.shader.setMat4("model", model); + + config.model.Draw(config.shader); +} + +void draw_cube(Config& config, glm::mat4& projection, glm::mat4& view) { + config.shader.use(); + config.shader.setVec3("objectColor", 1.0f, 0.5f, 0.31f); + config.shader.setVec3("lightColor", 1.0f, 1.0f, 1.0f); + // THIS WAS MISSING + config.shader.setVec3("lightPos", config.lightPos); + + config.shader.setMat4("view", view); + config.shader.setMat4("projection", projection); + config.shader.setVec3("viewPos", config.camera.pos); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, config.boxPos); + config.shader.setMat4("model", model); + glBindVertexArray(config.cubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); +} + +void draw_light(Config& config, glm::mat4& projection, glm::mat4& view) { + config.light.use(); + + config.light.setVec3("lightPos", config.lightPos); + config.light.setMat4("projection", projection); + config.light.setMat4("view", view); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, config.lightPos); + model = glm::scale(model, glm::vec3(0.2f)); + config.light.setMat4("model", model); + + glBindVertexArray(config.lightCubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); +} + + +void render(GLFWwindow* window, Config& config, BoxTest& box, b2World& world) { + glClearColor(0.1f, 0.1f, 0.1f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + config.shader.use(); + + Box2d_step_world(world); + + // time is used for fake 3d rotation + float time = glfwGetTime(); + + config.camera.update(config.deltaTime); + + glm::mat4 view = config.camera.lookAt(); + glm::mat4 projection = glm::mat4(1.0f); + // fov, aspect, near plane, far plane + projection = glm::perspective(glm::radians(config.camera.fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); + + // update light color + draw_cube(config, projection, view); + + // the 0 is for which popcorn, so later when we have N for-loop + draw_popcorn(config, box, 0, projection, view); + + draw_light(config, projection, view); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.VBO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + auto config = setup(); + + glfwSetWindowUserPointer(window, &config.camera); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box, config.camera); + render(window, config, box, world); + config.updateDelta(); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/09-basic-light-materials/src/mesh.cpp b/09-basic-light-materials/src/mesh.cpp new file mode 100644 index 0000000..a05e18b --- /dev/null +++ b/09-basic-light-materials/src/mesh.cpp @@ -0,0 +1,57 @@ +#include "mesh.hpp" + +void Mesh::Draw(Shader &shader) { + unsigned int diffuseNr = 1; + unsigned int specularNr = 1; + unsigned int normalNr = 1; + unsigned int heightNr = 1; + + for(unsigned int i = 0; i < textures.size(); i++) { + glActiveTexture(GL_TEXTURE0 + i); + std::string number; + std::string name = textures[i].type; + + if(name == "texture_diffuse") { + number = std::to_string(diffuseNr++); + } else if(name == "texture_specular") { + number = std::to_string(specularNr++); + } else if(name == "texture_normal") { + number = std::to_string(normalNr++); + } else if(name == "texture_height") { + number = std::to_string(heightNr++); + } + + // TODO: Get this uniform ID once and cache it? + glUniform1i(glGetUniformLocation(shader.ID, (name + number).c_str()), i); + glBindTexture(GL_TEXTURE_2D, textures[i].id); + } + + glBindVertexArray(VAO); + glDrawElements(GL_TRIANGLES, static_cast(indices.size()), GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + + glActiveTexture(GL_TEXTURE0); +} + + +void Mesh::setupMesh() { + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Position)); + + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal)); + + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords)); +} diff --git a/09-basic-light-materials/src/mesh.hpp b/09-basic-light-materials/src/mesh.hpp new file mode 100644 index 0000000..50b515d --- /dev/null +++ b/09-basic-light-materials/src/mesh.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +#include "shader.hpp" + +#include +#include + +struct Vertex { + glm::vec3 Position; + glm::vec3 Normal; + glm::vec2 TexCoords; +}; + +struct Texture { + unsigned int id; + std::string type; + std::string path; +}; + +struct Mesh { + std::vector vertices; + std::vector indices; + std::vector textures; + unsigned int VAO; + unsigned int VBO; + unsigned int EBO; + + Mesh(std::vector vertices, std::vector indices, std::vector textures) : + vertices(vertices), + indices(indices), + textures(textures) + { + setupMesh(); + } + + void Draw(Shader &shader); + void setupMesh(); +}; diff --git a/09-basic-light-materials/src/model.cpp b/09-basic-light-materials/src/model.cpp new file mode 100644 index 0000000..e6b2fdd --- /dev/null +++ b/09-basic-light-materials/src/model.cpp @@ -0,0 +1,171 @@ +#include "model.hpp" +#include "dbc.hpp" + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma) +{ + std::string filename = path + "/" + filename; + + unsigned int textureID; + glGenTextures(1, &textureID); + + int width = 0; + int height = 0; + int nrComponents = 0; + + unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0); + dbc::check(data != nullptr, $F("Failed to load texture {}", filename)); + + GLenum format = GL_RGB; + + if (nrComponents == 1) { + format = GL_RED; + } else if (nrComponents == 3) { + format = GL_RGB; + } else if (nrComponents == 4) { + format = GL_RGBA; + } + + glBindTexture(GL_TEXTURE_2D, textureID); + glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + stbi_image_free(data); + + return textureID; +} + +void Model::Draw(Shader &shader) { + for(unsigned int i = 0; i < meshes.size(); i++) { + meshes[i].Draw(shader); + } +} + +void Model::loadModel(std::string path) { + Assimp::Importer importer; + const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); + + dbc::check(scene != nullptr, "Assimp ReadFile return null"); + dbc::check(!(scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE), "Assimp says incomplete."); + dbc::check(scene->mRootNode != nullptr, "Assimp loaded scene doesn't have a root node"); + + directory = path.substr(0, path.find_last_of('/')); + + processNode(scene->mRootNode, scene); +} + +void Model::processNode(aiNode *node, const aiScene *scene) { + for(unsigned int i = 0; i < node->mNumMeshes; i++) { + aiMesh* mesh = scene->mMeshes[node->mMeshes[i]]; + meshes.push_back(processMesh(mesh, scene)); + } + + for(unsigned int i = 0; i < node->mNumChildren; i++) { + processNode(node->mChildren[i], scene); + } +} + +Mesh Model::processMesh(aiMesh *mesh, const aiScene *scene) { + std::vector vertices; + std::vector indices; + std::vector textures; + + for(unsigned int i = 0; i < mesh->mNumVertices; i++) { + Vertex vertex; + vertex.Position = glm::vec3( + mesh->mVertices[i].x, + mesh->mVertices[i].y, + mesh->mVertices[i].z); + + if(mesh->HasNormals()) { + vertex.Normal = glm::vec3( + mesh->mNormals[i].x, + mesh->mNormals[i].y, + mesh->mNormals[i].z); + } + + if(mesh->mTextureCoords[0]) { + vertex.TexCoords = glm::vec2( + mesh->mTextureCoords[0][i].x, + mesh->mTextureCoords[0][i].y + ); + } else { + vertex.TexCoords = glm::vec2(0.0f, 0.0f); + } + + vertices.push_back(vertex); + } + + for(unsigned int i = 0; i < mesh->mNumFaces; i++) { + aiFace face = mesh->mFaces[i]; + + for(unsigned int j = 0; j < face.mNumIndices; j++) { + indices.push_back(face.mIndices[j]); + } + } + + aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex]; + + // we assume a convention for sampler names in the shaders. Each diffuse texture should be named + // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. + // Same applies to other texture as the following list summarizes: + // diffuse: texture_diffuseN + // specular: texture_specularN + // normal: texture_normalN + + // 1. diffuse maps + std::vector diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse"); + textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); + + // 2. specular maps + std::vector specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular"); + textures.insert(textures.end(), specularMaps.begin(), specularMaps.end()); + + // 3. normal maps + std::vector normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal"); + textures.insert(textures.end(), normalMaps.begin(), normalMaps.end()); + + // 4. height maps + std::vector heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height"); + textures.insert(textures.end(), heightMaps.begin(), heightMaps.end()); + + return Mesh(vertices, indices, textures); +} + +std::vector Model::loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName) +{ + fmt::println("TEXTURE COUNT: {}, {}, {}", (int)type, typeName, mat->GetTextureCount(type)); + + std::vector textures; + for(unsigned int i = 0; i < mat->GetTextureCount(type); i++) { + aiString str; + mat->GetTexture(type, i, &str); + std::string tx_str{str.C_Str()}; + + bool skip = false; + for(unsigned int j = 0; j < textures_loaded.size(); j++) { + if(textures_loaded[j].path == tx_str) { + textures.push_back(textures_loaded[j]); + skip = true; + break; + } + } + + if(!skip) { + Texture texture{ + .id = TextureFromFile(tx_str, directory), + .type = typeName, + .path = tx_str, + }; + + textures.push_back(texture); + textures_loaded.push_back(texture); + } + } + + return textures; +} diff --git a/09-basic-light-materials/src/model.hpp b/09-basic-light-materials/src/model.hpp new file mode 100644 index 0000000..8d23203 --- /dev/null +++ b/09-basic-light-materials/src/model.hpp @@ -0,0 +1,40 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma = false); + +struct Model { + std::vector textures_loaded; + std::vector meshes; + std::string directory; + bool gammaCorrection; + + Model(const char *path) { + loadModel(path); + } + + void Draw(Shader &shader); + + void loadModel(std::string path); + void processNode(aiNode *node, const aiScene *scene); + Mesh processMesh(aiMesh *mesh, const aiScene *scene); + + std::vector loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName); +}; diff --git a/09-basic-light-materials/src/physics.cpp b/09-basic-light-materials/src/physics.cpp new file mode 100644 index 0000000..daa8f87 --- /dev/null +++ b/09-basic-light-materials/src/physics.cpp @@ -0,0 +1,49 @@ +#include "physics.hpp" + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + for(size_t i = 0; i < BODY_COUNT; i++) { + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.5f); + box.bodies[i] = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.bodies[i]->CreateFixture(&fixtureDef); + } + + return box; +} + +void Box2d_step_world(b2World& world) { + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); +} diff --git a/09-basic-light-materials/src/physics.hpp b/09-basic-light-materials/src/physics.hpp new file mode 100644 index 0000000..dc98a31 --- /dev/null +++ b/09-basic-light-materials/src/physics.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +#define BODY_COUNT 1 + +struct BoxTest { + b2Body *walls[4]; + b2Body *bodies[BODY_COUNT]; +}; + +struct BoxTest Box2d_setup(b2World &world); +void Box2d_step_world(b2World& world); diff --git a/09-basic-light-materials/src/shader.cpp b/09-basic-light-materials/src/shader.cpp new file mode 100644 index 0000000..a89af73 --- /dev/null +++ b/09-basic-light-materials/src/shader.cpp @@ -0,0 +1,126 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" +#include +#include +#include + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} + +void Shader::setVec4(const std::string &name, const glm::vec4& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, const glm::vec3& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, float v1, float v2, float v3) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3f(uniform, v1, v2, v3); +} + +void Shader::setMat4(const std::string &name, const glm::mat4& mat) const { + unsigned int loc = glGetUniformLocation(ID, name.c_str()); + glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(mat)); +} diff --git a/09-basic-light-materials/src/shader.hpp b/09-basic-light-materials/src/shader.hpp new file mode 100644 index 0000000..afa8f05 --- /dev/null +++ b/09-basic-light-materials/src/shader.hpp @@ -0,0 +1,25 @@ +#pragma once + +#include +#include +#include +#include + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void setVec4(const std::string &name, const glm::vec4& value) const; + void setVec3(const std::string &name, float v1, float v2, float v3) const; + void setVec3(const std::string &name, const glm::vec3& value) const; + void setMat4(const std::string &name, const glm::mat4& what) const; + void cleanup(); +}; diff --git a/09-basic-light-materials/src/stb_image.cpp b/09-basic-light-materials/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/09-basic-light-materials/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/09-basic-light-materials/src/stb_image.h b/09-basic-light-materials/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/09-basic-light-materials/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/09-basic-light-materials/tests/bad_shader.vs b/09-basic-light-materials/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/09-basic-light-materials/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/09-basic-light-materials/tests/main.cpp b/09-basic-light-materials/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/09-basic-light-materials/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/09-basic-light-materials/tests/meson.build b/09-basic-light-materials/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/09-basic-light-materials/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/09-basic-light-materials/tests/shader_tests.cpp b/09-basic-light-materials/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/09-basic-light-materials/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/09-basic-light-materials/wraps/assimp.wrap b/09-basic-light-materials/wraps/assimp.wrap new file mode 100644 index 0000000..4bb6029 --- /dev/null +++ b/09-basic-light-materials/wraps/assimp.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=assimp-5.4.3 +url=https://github.com/assimp/assimp.git +revision=v5.4.3 +depth=1 +method=cmake + +[provide] +assimp = assimp_dep diff --git a/09-basic-light-materials/wraps/box2d.wrap b/09-basic-light-materials/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/09-basic-light-materials/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/09-basic-light-materials/wraps/fmt.wrap b/09-basic-light-materials/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/09-basic-light-materials/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/09-basic-light-materials/wraps/fuc2.wrap b/09-basic-light-materials/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/09-basic-light-materials/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/09-basic-light-materials/wraps/glfw.wrap b/09-basic-light-materials/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/09-basic-light-materials/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/09-basic-light-materials/wraps/glm.wrap b/09-basic-light-materials/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/09-basic-light-materials/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep diff --git a/10-materials/.gitignore b/10-materials/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/10-materials/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/10-materials/.vimrc_proj b/10-materials/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/10-materials/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/10-materials/KHR/khrplatform.h b/10-materials/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/10-materials/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/10-materials/LICENSE b/10-materials/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/10-materials/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/10-materials/Makefile b/10-materials/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/10-materials/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/10-materials/assets/popcorn_model_a.glb b/10-materials/assets/popcorn_model_a.glb new file mode 100644 index 0000000000000000000000000000000000000000..dc02c851484560bbb0cdecd5e1cca2458dce10ea GIT binary patch literal 18016 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 +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/10-materials/glad/glad.h b/10-materials/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/10-materials/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/10-materials/meson.build b/10-materials/meson.build new file mode 100644 index 0000000..a971022 --- /dev/null +++ b/10-materials/meson.build @@ -0,0 +1,100 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +assimp = subproject('assimp').get_variable('assimp_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d, assimp +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', + 'src/physics.cpp', + 'src/mesh.cpp', + 'src/model.cpp', + 'src/camera.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/10-materials/resources/textures/awesomeface.png b/10-materials/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 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 Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/10-materials/resources/textures/container.jpg b/10-materials/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys 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[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/10-materials/resources/textures/popcorn.jpg b/10-materials/resources/textures/popcorn.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f82106f468a6c55a285390b2603c58bafc6df8d GIT binary patch literal 6006 zcmeHHNlX+$6#doJ+w>4a!wf1OWYv)vGCjkv%!L4gK*R{*dK*-9JeYteXkr4mpq>Ob z^aQwo-cZ5iU_f!>hAZI3an}>LOQP+s2El^|^=Rr>>euV4|11AhRX=mkd;;Nxc?Eeu z2!VWTV20p(ZcVTppr{Cv06+yh0icM8P>YUC;Aw2a!fdUH$m8=M;JkAJ;|hreiREH% zCbK4S3vvAtZ?G)D9ifAGEbKts-4Fy3N0!@OE$pc zHoSg!y5F4|V`TV!Y5o*9R(}9M!5q=;@fa<_&s_y*p;H*w(agt?0|FigAVod`hus2`k3v9k>pnE=9x|S#o4?K#8kxcEJz3;}&Tet7@-@SML!NW&`L&Kq`&z`?{`RetXx1;agfB5+6^Ovtd0mIAy-1Kgj@-^ f5^^QvO30OvD>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/10-materials/scripts/windows_setup.ps1 b/10-materials/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/10-materials/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/10-materials/shaders/08-frag.glsl b/10-materials/shaders/08-frag.glsl new file mode 100644 index 0000000..5b3d816 --- /dev/null +++ b/10-materials/shaders/08-frag.glsl @@ -0,0 +1,43 @@ +#version 330 core +struct Material { + vec3 ambient; + vec3 diffuse; + vec3 specular; + float shininess; +}; + +struct Light { + vec3 position; + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +uniform Light light; + +uniform Material material; +out vec4 FragColor; +in vec3 FragPos; +in vec3 Normal; + +uniform vec3 viewPos; + +void main() +{ + vec3 ambient = light.ambient * material.ambient; + + vec3 norm = normalize(Normal); + vec3 lightDir = normalize(light.position - FragPos); + float diff = max(dot(norm, lightDir), 0.0); + vec3 diffuse = light.diffuse * (diff * material.diffuse); + + vec3 viewDir = normalize(viewPos - FragPos); + vec3 reflectDir = reflect(-lightDir, norm); + + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + vec3 specular = light.specular * (material.specular * spec); + + vec3 result = ambient + diffuse + specular; + + FragColor = vec4(result, 1.0); +} diff --git a/10-materials/shaders/08-lightsource.frag.glsl b/10-materials/shaders/08-lightsource.frag.glsl new file mode 100644 index 0000000..c208aa1 --- /dev/null +++ b/10-materials/shaders/08-lightsource.frag.glsl @@ -0,0 +1,16 @@ +#version 330 core +out vec4 FragColor; + +struct Light { + vec3 position; + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +uniform Light light; + +void main() +{ + FragColor = vec4(light.diffuse, 1.0); // set all 4 vector values to 1.0 +} diff --git a/10-materials/shaders/08-vert.glsl b/10-materials/shaders/08-vert.glsl new file mode 100644 index 0000000..eda4400 --- /dev/null +++ b/10-materials/shaders/08-vert.glsl @@ -0,0 +1,17 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; + +out vec3 FragPos; +out vec3 Normal; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + FragPos = vec3(model * vec4(aPos, 1.0)); + Normal = mat3(transpose(inverse(model))) * aNormal; +} diff --git a/10-materials/shaders/3.3.shader.fs b/10-materials/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/10-materials/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/10-materials/shaders/3.3.shader.vs b/10-materials/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/10-materials/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/10-materials/shaders/4.2.texture.fs b/10-materials/shaders/4.2.texture.fs new file mode 100644 index 0000000..80ee6a7 --- /dev/null +++ b/10-materials/shaders/4.2.texture.fs @@ -0,0 +1,11 @@ +#version 330 core + +out vec4 FragColor; +in vec2 TexCoord; + +uniform sampler2D texture1; + +void main() +{ + FragColor = texture(texture1, TexCoord); +} diff --git a/10-materials/shaders/4.2.texture.vs b/10-materials/shaders/4.2.texture.vs new file mode 100644 index 0000000..85c9de7 --- /dev/null +++ b/10-materials/shaders/4.2.texture.vs @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTexCoord; + +out vec2 TexCoord; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/10-materials/src/camera.cpp b/10-materials/src/camera.cpp new file mode 100644 index 0000000..1c456a7 --- /dev/null +++ b/10-materials/src/camera.cpp @@ -0,0 +1,63 @@ +#include "camera.hpp" +#include +#include + +glm::mat4 Camera::lookAt() { + return glm::lookAt(pos, pos + front, up); +} + +void Camera::forward() { + pos += speed * front; +} + +void Camera::back() { + pos -= speed * front; +} + +void Camera::left() { + pos -= glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::right() { + pos += glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::update(float deltaTime) { + speed = movementSpeed * deltaTime; +} + +void Camera::mouse_move(double xpos, double ypos) { + if(firstMouse) { + lastX = xpos; + lastY = ypos; + firstMouse = false; + } + + float xoffset = xpos - lastX; + float yoffset = lastY - ypos; + lastX = xpos; + lastY = ypos; + + const float sensitivity = 0.1f; + xoffset *= sensitivity; + yoffset *= sensitivity; + + yaw += xoffset; + pitch += yoffset; + + if(pitch > 89.0f) pitch = 89.0f; + if(pitch < -89.0f) pitch = -89.0f; + + direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); + direction.y = sin(glm::radians(pitch)); + direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); + + front = glm::normalize(direction); +} + +void Camera::mouse_scroll(double xoffset, double yoffset) { + fov -= (float)yoffset; + + if(fov < 1.0f) fov = 1.0f; + if(fov > 90.0f) fov = 90.0f; +} diff --git a/10-materials/src/camera.hpp b/10-materials/src/camera.hpp new file mode 100644 index 0000000..91fe1f7 --- /dev/null +++ b/10-materials/src/camera.hpp @@ -0,0 +1,27 @@ +#pragma once +#include + +struct Camera { + glm::vec3 pos = glm::vec3(0.0f, 0.0f, 3.0f); + glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f); + glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f); + glm::vec3 direction = glm::vec3(0.0f, 0.0f, 0.0f); + float movementSpeed = 20.0f; + + float pitch = 0.0f; + float yaw = -90.0f; + float speed = 0.05f; + float lastX = 400; + float lastY = 300; + float fov = 45.0f; + bool firstMouse = true; + + glm::mat4 lookAt(); + void forward(); + void back(); + void left(); + void right(); + void update(float deltaTime); + void mouse_move(double xpos, double ypos); + void mouse_scroll(double xoffset, double yoffset); +}; diff --git a/10-materials/src/data.hpp b/10-materials/src/data.hpp new file mode 100644 index 0000000..83245f2 --- /dev/null +++ b/10-materials/src/data.hpp @@ -0,0 +1,46 @@ +#pragma once +#include + +float vertices[] = { + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f +}; diff --git a/10-materials/src/dbc.cpp b/10-materials/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/10-materials/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/10-materials/src/dbc.hpp b/10-materials/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/10-materials/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/10-materials/src/main.cpp b/10-materials/src/main.cpp new file mode 100644 index 0000000..42e8237 --- /dev/null +++ b/10-materials/src/main.cpp @@ -0,0 +1,334 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include "data.hpp" +#include "physics.hpp" +#include "model.hpp" +#include "camera.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + Shader shader; + Shader lightShader; + Model model; + + Light light{ + .position={1.2f, 1.0f, 2.0f}, + .ambient={0.2f, 0.2f, 0.2f}, + .diffuse={0.8f, 0.8f, 0.8f}, + .specular={1.0f, 1.0f, 1.0f}, + }; + + glm::vec3 boxPos{2.0f, 0.0f, 0.0f}; + unsigned int cubeVAO = 0; + unsigned int lightCubeVAO = 0; + unsigned int VBO = 0; + Camera camera{.movementSpeed=2.0f}; + float deltaTime = 0.0f; + float lastFrame = 0.0f; + + void updateDelta() { + float currentFrame = glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; + } +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +void mouse_callback(GLFWwindow *window, double xpos, double ypos) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_move(xpos, ypos); +} + +void scroll_callback(GLFWwindow *window, double xoffset, double yoffset) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_scroll(xoffset, yoffset); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); + glfwSetCursorPosCallback(window, mouse_callback); + glfwSetScrollCallback(window, scroll_callback); + + return window; +} + + +void processInput(GLFWwindow *window, BoxTest &box, Camera& camera) { + + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + for(size_t i = 0; i < BODY_COUNT; i++) { + box.bodies[i]->ApplyForceToCenter(force, true); + box.bodies[i]->ApplyTorque(0.1f, true); + } + } + + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { + camera.forward(); + } + + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { + camera.back(); + } + + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { + camera.left(); + } + + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { + camera.right(); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + glEnable(GL_DEPTH_TEST); + + Config config{ + .shader={"shaders/08-vert.glsl", "shaders/08-frag.glsl"}, + .lightShader={"shaders/08-vert.glsl", "shaders/08-lightsource.frag.glsl"}, + .model={"assets/popcorn_model_a.glb"} + }; + + unsigned int VBO = 0; + unsigned int lightCubeVAO = 0; + unsigned int cubeVAO = 0; + + // cube vao configure, this is the light target + glGenVertexArrays(1, &cubeVAO); + glGenBuffers(1, &VBO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + glBindVertexArray(cubeVAO); + + // position attribute + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + // light vao configure, this is the light source + glGenVertexArrays(1, &lightCubeVAO); + glBindVertexArray(lightCubeVAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + config.lightCubeVAO = lightCubeVAO; + config.cubeVAO = cubeVAO; + config.VBO = VBO; + + return config; +} + +void draw_popcorn(Config& config, BoxTest& box, size_t box_i, glm::mat4& projection, glm::mat4& view) +{ + config.shader.use(); + + config.shader.setMat4("view", view); + config.shader.setMat4("projection", projection); + config.shader.setVec3("viewPos", config.camera.pos); + + config.shader.applyLight(config.light); + + glm::vec3 objectColor = {1.0, 0.94, 0.78}; + config.shader.applyMaterial({ + .ambient = objectColor, + .diffuse = objectColor, + .specular = objectColor, + .shininess = 100000.0f}); + + float time = glfwGetTime(); + // get position from box + b2Vec2 position = box.bodies[box_i]->GetPosition(); + float angle = box.bodies[box_i]->GetAngle(); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, glm::vec3(position.x, position.y, 0.0f)); + + model = glm::rotate(model, angle / 5.0f, glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(time * 10.0f), glm::vec3(0.0f, 1.0f, 1.0f)); + + config.shader.setMat4("model", model); + + config.model.Draw(config.shader); +} + +void draw_cube(Config& config, glm::mat4& projection, glm::mat4& view) { + config.shader.use(); + + config.shader.applyLight(config.light); + + config.shader.setMat4("view", view); + config.shader.setMat4("projection", projection); + config.shader.setVec3("viewPos", config.camera.pos); + config.shader.applyMaterial({ + .ambient = {1.0f, 0.5f, 0.31f}, + .diffuse = {1.0f, 0.5f, 0.31f}, + .specular = config.light.specular, + .shininess = 32.0f}); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, config.boxPos); + config.shader.setMat4("model", model); + glBindVertexArray(config.cubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); +} + +void draw_light(Config& config, glm::mat4& projection, glm::mat4& view) { + config.lightShader.use(); + + config.lightShader.applyLight(config.light); + config.lightShader.setMat4("projection", projection); + config.lightShader.setMat4("view", view); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, config.light.position); + model = glm::scale(model, glm::vec3(0.2f)); + config.lightShader.setMat4("model", model); + + glBindVertexArray(config.lightCubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); +} + + +void render(GLFWwindow* window, Config& config, BoxTest& box, b2World& world) { + glClearColor(0.1f, 0.1f, 0.1f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + config.shader.use(); + + Box2d_step_world(world); + + // time is used for fake 3d rotation + float time = glfwGetTime(); + + config.camera.update(config.deltaTime); + + glm::mat4 view = config.camera.lookAt(); + glm::mat4 projection = glm::mat4(1.0f); + // fov, aspect, near plane, far plane + projection = glm::perspective(glm::radians(config.camera.fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); + + // update light color + draw_cube(config, projection, view); + + // the 0 is for which popcorn, so later when we have N for-loop + draw_popcorn(config, box, 0, projection, view); + + draw_light(config, projection, view); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.VBO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + auto config = setup(); + + glfwSetWindowUserPointer(window, &config.camera); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box, config.camera); + render(window, config, box, world); + config.updateDelta(); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/10-materials/src/mesh.cpp b/10-materials/src/mesh.cpp new file mode 100644 index 0000000..a05e18b --- /dev/null +++ b/10-materials/src/mesh.cpp @@ -0,0 +1,57 @@ +#include "mesh.hpp" + +void Mesh::Draw(Shader &shader) { + unsigned int diffuseNr = 1; + unsigned int specularNr = 1; + unsigned int normalNr = 1; + unsigned int heightNr = 1; + + for(unsigned int i = 0; i < textures.size(); i++) { + glActiveTexture(GL_TEXTURE0 + i); + std::string number; + std::string name = textures[i].type; + + if(name == "texture_diffuse") { + number = std::to_string(diffuseNr++); + } else if(name == "texture_specular") { + number = std::to_string(specularNr++); + } else if(name == "texture_normal") { + number = std::to_string(normalNr++); + } else if(name == "texture_height") { + number = std::to_string(heightNr++); + } + + // TODO: Get this uniform ID once and cache it? + glUniform1i(glGetUniformLocation(shader.ID, (name + number).c_str()), i); + glBindTexture(GL_TEXTURE_2D, textures[i].id); + } + + glBindVertexArray(VAO); + glDrawElements(GL_TRIANGLES, static_cast(indices.size()), GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + + glActiveTexture(GL_TEXTURE0); +} + + +void Mesh::setupMesh() { + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Position)); + + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal)); + + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords)); +} diff --git a/10-materials/src/mesh.hpp b/10-materials/src/mesh.hpp new file mode 100644 index 0000000..50b515d --- /dev/null +++ b/10-materials/src/mesh.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +#include "shader.hpp" + +#include +#include + +struct Vertex { + glm::vec3 Position; + glm::vec3 Normal; + glm::vec2 TexCoords; +}; + +struct Texture { + unsigned int id; + std::string type; + std::string path; +}; + +struct Mesh { + std::vector vertices; + std::vector indices; + std::vector textures; + unsigned int VAO; + unsigned int VBO; + unsigned int EBO; + + Mesh(std::vector vertices, std::vector indices, std::vector textures) : + vertices(vertices), + indices(indices), + textures(textures) + { + setupMesh(); + } + + void Draw(Shader &shader); + void setupMesh(); +}; diff --git a/10-materials/src/model.cpp b/10-materials/src/model.cpp new file mode 100644 index 0000000..e6b2fdd --- /dev/null +++ b/10-materials/src/model.cpp @@ -0,0 +1,171 @@ +#include "model.hpp" +#include "dbc.hpp" + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma) +{ + std::string filename = path + "/" + filename; + + unsigned int textureID; + glGenTextures(1, &textureID); + + int width = 0; + int height = 0; + int nrComponents = 0; + + unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0); + dbc::check(data != nullptr, $F("Failed to load texture {}", filename)); + + GLenum format = GL_RGB; + + if (nrComponents == 1) { + format = GL_RED; + } else if (nrComponents == 3) { + format = GL_RGB; + } else if (nrComponents == 4) { + format = GL_RGBA; + } + + glBindTexture(GL_TEXTURE_2D, textureID); + glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + stbi_image_free(data); + + return textureID; +} + +void Model::Draw(Shader &shader) { + for(unsigned int i = 0; i < meshes.size(); i++) { + meshes[i].Draw(shader); + } +} + +void Model::loadModel(std::string path) { + Assimp::Importer importer; + const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); + + dbc::check(scene != nullptr, "Assimp ReadFile return null"); + dbc::check(!(scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE), "Assimp says incomplete."); + dbc::check(scene->mRootNode != nullptr, "Assimp loaded scene doesn't have a root node"); + + directory = path.substr(0, path.find_last_of('/')); + + processNode(scene->mRootNode, scene); +} + +void Model::processNode(aiNode *node, const aiScene *scene) { + for(unsigned int i = 0; i < node->mNumMeshes; i++) { + aiMesh* mesh = scene->mMeshes[node->mMeshes[i]]; + meshes.push_back(processMesh(mesh, scene)); + } + + for(unsigned int i = 0; i < node->mNumChildren; i++) { + processNode(node->mChildren[i], scene); + } +} + +Mesh Model::processMesh(aiMesh *mesh, const aiScene *scene) { + std::vector vertices; + std::vector indices; + std::vector textures; + + for(unsigned int i = 0; i < mesh->mNumVertices; i++) { + Vertex vertex; + vertex.Position = glm::vec3( + mesh->mVertices[i].x, + mesh->mVertices[i].y, + mesh->mVertices[i].z); + + if(mesh->HasNormals()) { + vertex.Normal = glm::vec3( + mesh->mNormals[i].x, + mesh->mNormals[i].y, + mesh->mNormals[i].z); + } + + if(mesh->mTextureCoords[0]) { + vertex.TexCoords = glm::vec2( + mesh->mTextureCoords[0][i].x, + mesh->mTextureCoords[0][i].y + ); + } else { + vertex.TexCoords = glm::vec2(0.0f, 0.0f); + } + + vertices.push_back(vertex); + } + + for(unsigned int i = 0; i < mesh->mNumFaces; i++) { + aiFace face = mesh->mFaces[i]; + + for(unsigned int j = 0; j < face.mNumIndices; j++) { + indices.push_back(face.mIndices[j]); + } + } + + aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex]; + + // we assume a convention for sampler names in the shaders. Each diffuse texture should be named + // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. + // Same applies to other texture as the following list summarizes: + // diffuse: texture_diffuseN + // specular: texture_specularN + // normal: texture_normalN + + // 1. diffuse maps + std::vector diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse"); + textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); + + // 2. specular maps + std::vector specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular"); + textures.insert(textures.end(), specularMaps.begin(), specularMaps.end()); + + // 3. normal maps + std::vector normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal"); + textures.insert(textures.end(), normalMaps.begin(), normalMaps.end()); + + // 4. height maps + std::vector heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height"); + textures.insert(textures.end(), heightMaps.begin(), heightMaps.end()); + + return Mesh(vertices, indices, textures); +} + +std::vector Model::loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName) +{ + fmt::println("TEXTURE COUNT: {}, {}, {}", (int)type, typeName, mat->GetTextureCount(type)); + + std::vector textures; + for(unsigned int i = 0; i < mat->GetTextureCount(type); i++) { + aiString str; + mat->GetTexture(type, i, &str); + std::string tx_str{str.C_Str()}; + + bool skip = false; + for(unsigned int j = 0; j < textures_loaded.size(); j++) { + if(textures_loaded[j].path == tx_str) { + textures.push_back(textures_loaded[j]); + skip = true; + break; + } + } + + if(!skip) { + Texture texture{ + .id = TextureFromFile(tx_str, directory), + .type = typeName, + .path = tx_str, + }; + + textures.push_back(texture); + textures_loaded.push_back(texture); + } + } + + return textures; +} diff --git a/10-materials/src/model.hpp b/10-materials/src/model.hpp new file mode 100644 index 0000000..8d23203 --- /dev/null +++ b/10-materials/src/model.hpp @@ -0,0 +1,40 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma = false); + +struct Model { + std::vector textures_loaded; + std::vector meshes; + std::string directory; + bool gammaCorrection; + + Model(const char *path) { + loadModel(path); + } + + void Draw(Shader &shader); + + void loadModel(std::string path); + void processNode(aiNode *node, const aiScene *scene); + Mesh processMesh(aiMesh *mesh, const aiScene *scene); + + std::vector loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName); +}; diff --git a/10-materials/src/physics.cpp b/10-materials/src/physics.cpp new file mode 100644 index 0000000..daa8f87 --- /dev/null +++ b/10-materials/src/physics.cpp @@ -0,0 +1,49 @@ +#include "physics.hpp" + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + for(size_t i = 0; i < BODY_COUNT; i++) { + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.5f); + box.bodies[i] = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.bodies[i]->CreateFixture(&fixtureDef); + } + + return box; +} + +void Box2d_step_world(b2World& world) { + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); +} diff --git a/10-materials/src/physics.hpp b/10-materials/src/physics.hpp new file mode 100644 index 0000000..dc98a31 --- /dev/null +++ b/10-materials/src/physics.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +#define BODY_COUNT 1 + +struct BoxTest { + b2Body *walls[4]; + b2Body *bodies[BODY_COUNT]; +}; + +struct BoxTest Box2d_setup(b2World &world); +void Box2d_step_world(b2World& world); diff --git a/10-materials/src/shader.cpp b/10-materials/src/shader.cpp new file mode 100644 index 0000000..a89af73 --- /dev/null +++ b/10-materials/src/shader.cpp @@ -0,0 +1,126 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" +#include +#include +#include + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} + +void Shader::setVec4(const std::string &name, const glm::vec4& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, const glm::vec3& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, float v1, float v2, float v3) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3f(uniform, v1, v2, v3); +} + +void Shader::setMat4(const std::string &name, const glm::mat4& mat) const { + unsigned int loc = glGetUniformLocation(ID, name.c_str()); + glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(mat)); +} diff --git a/10-materials/src/shader.hpp b/10-materials/src/shader.hpp new file mode 100644 index 0000000..947a7f9 --- /dev/null +++ b/10-materials/src/shader.hpp @@ -0,0 +1,53 @@ +#pragma once + +#include +#include +#include +#include + +struct Material { + glm::vec3 ambient{0.1f,0.1f,0.1f}; + glm::vec3 diffuse{0.5f,0.5f,0.5f}; + glm::vec3 specular{0.8f, 0.8f, 0.8f}; + float shininess{32.0f}; +}; + +struct Light { + glm::vec3 position; + glm::vec3 ambient; + glm::vec3 diffuse; + glm::vec3 specular; +}; + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void setVec4(const std::string &name, const glm::vec4& value) const; + void setVec3(const std::string &name, float v1, float v2, float v3) const; + void setVec3(const std::string &name, const glm::vec3& value) const; + void setMat4(const std::string &name, const glm::mat4& what) const; + void cleanup(); + + void applyMaterial(const Material& material) { + setVec3("material.ambient", material.ambient); + setVec3("material.diffuse", material.diffuse); + setVec3("material.specular", material.specular); + setFloat("material.shininess", material.shininess); + } + + void applyLight(const Light& light) { + setVec3("light.position", light.position); + setVec3("light.ambient", light.ambient); + setVec3("light.diffuse", light.diffuse); + setVec3("light.specular", light.specular); + } +}; diff --git a/10-materials/src/stb_image.cpp b/10-materials/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/10-materials/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/10-materials/src/stb_image.h b/10-materials/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/10-materials/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/10-materials/tests/bad_shader.vs b/10-materials/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/10-materials/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/10-materials/tests/main.cpp b/10-materials/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/10-materials/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/10-materials/tests/meson.build b/10-materials/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/10-materials/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/10-materials/tests/shader_tests.cpp b/10-materials/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/10-materials/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/10-materials/wraps/assimp.wrap b/10-materials/wraps/assimp.wrap new file mode 100644 index 0000000..4bb6029 --- /dev/null +++ b/10-materials/wraps/assimp.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=assimp-5.4.3 +url=https://github.com/assimp/assimp.git +revision=v5.4.3 +depth=1 +method=cmake + +[provide] +assimp = assimp_dep diff --git a/10-materials/wraps/box2d.wrap b/10-materials/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/10-materials/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/10-materials/wraps/fmt.wrap b/10-materials/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/10-materials/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/10-materials/wraps/fuc2.wrap b/10-materials/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/10-materials/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/10-materials/wraps/glfw.wrap b/10-materials/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/10-materials/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/10-materials/wraps/glm.wrap b/10-materials/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/10-materials/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep diff --git a/11-lightmaps/.gitignore b/11-lightmaps/.gitignore new file mode 100644 index 0000000..7999676 --- /dev/null +++ b/11-lightmaps/.gitignore @@ -0,0 +1,10 @@ +.*.sw* +.DS_Store +*.sqlite3 +*.sqlite3-wal +*.sqlite3-shm +debug +coverage/ +.coverage +builddir +subprojects diff --git a/11-lightmaps/.vimrc_proj b/11-lightmaps/.vimrc_proj new file mode 100644 index 0000000..2b745b4 --- /dev/null +++ b/11-lightmaps/.vimrc_proj @@ -0,0 +1 @@ +set makeprg=meson\ compile\ -C\ . diff --git a/11-lightmaps/KHR/khrplatform.h b/11-lightmaps/KHR/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/11-lightmaps/KHR/khrplatform.h @@ -0,0 +1,311 @@ +#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; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# 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 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#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 KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +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_ */ diff --git a/11-lightmaps/LICENSE b/11-lightmaps/LICENSE new file mode 100644 index 0000000..a4e9dc9 --- /dev/null +++ b/11-lightmaps/LICENSE @@ -0,0 +1,16 @@ +MIT No Attribution + +Copyright + +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. + +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. diff --git a/11-lightmaps/Makefile b/11-lightmaps/Makefile new file mode 100644 index 0000000..d9c78d6 --- /dev/null +++ b/11-lightmaps/Makefile @@ -0,0 +1,30 @@ +all: build + +reset: + powershell -executionpolicy bypass .\scripts\reset_build.ps1 + +build: + meson compile -j 4 -C builddir + +release_build: + meson --wipe builddir -Db_ndebug=true --buildtype release + meson compile -j 4 -C builddir + +debug_build: + meson setup --wipe builddir -Db_ndebug=true --buildtype debugoptimized + meson compile -j 4 -C builddir + +run: test + ./builddir/hellogl.exe + +test: build + ./builddir/fuc2it + +debug_test: build + gdb --nx -x .gdbinit --ex run --args builddir/fuc2it.exe + +debug_run: build + gdb --nx -x .gdbinit --batch --ex run --ex bt --ex q --args builddir/hellogl.exe + +clean: + meson compile --clean -C builddir diff --git a/11-lightmaps/assets/popcorn_model_a.glb b/11-lightmaps/assets/popcorn_model_a.glb new file mode 100644 index 0000000000000000000000000000000000000000..dc02c851484560bbb0cdecd5e1cca2458dce10ea GIT binary patch literal 18016 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 +#include +#include +#include + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/11-lightmaps/glad/glad.h b/11-lightmaps/glad/glad.h new file mode 100644 index 0000000..26f9677 --- /dev/null +++ b/11-lightmaps/glad/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Sat Nov 22 15:57:33 2025. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/11-lightmaps/meson.build b/11-lightmaps/meson.build new file mode 100644 index 0000000..a971022 --- /dev/null +++ b/11-lightmaps/meson.build @@ -0,0 +1,100 @@ +project('hellogl', 'cpp', + version: '0.1.0', + default_options: [ + 'cpp_std=c++23', + 'cpp_args=-D_GLIBCXX_DEBUG=1 -D_GLIBCXX_DEBUG_PEDANTIC=1', + ]) + +# use this for common options only for our executables +cpp_args=[ + '-Wno-unused-parameter', + '-Wno-unused-function', + '-Wno-unused-variable', + '-Wno-unused-but-set-variable', + '-Wno-deprecated-declarations', +] +link_args=[] +# these are passed as override_defaults +exe_defaults = [ 'warning_level=2' ] + +cc = meson.get_compiler('cpp') +dependencies = [] + +if build_machine.system() == 'windows' + add_global_link_arguments( + '-static-libgcc', + '-static-libstdc++', + '-static', + '-lstdc++exp', + language: 'cpp', + ) + + opengl32 = cc.find_library('opengl32', required: true) + winmm = cc.find_library('winmm', required: true) + gdi32 = cc.find_library('gdi32', required: true) + + dependencies += [ + opengl32, winmm, gdi32 + ] + exe_defaults += ['werror=true'] + +elif build_machine.system() == 'darwin' + add_global_link_arguments( + language: 'cpp', + ) + + opengl = dependency('OpenGL') + corefoundation = dependency('CoreFoundation') + carbon = dependency('Carbon') + cocoa = dependency('Cocoa') + iokit = dependency('IOKit') + corevideo = dependency('CoreVideo') + + link_args += ['-ObjC'] + exe_defaults += ['werror=false'] + dependencies += [ + opengl, corefoundation, carbon, cocoa, iokit, corevideo + ] +endif + +glfw3 = subproject('glfw').get_variable('glfw_dep') +fuc2 = subproject('fuc2').get_variable('fuc2_dep') +fmt = subproject('fmt').get_variable('fmt_dep') +glm = subproject('glm').get_variable('glm_dep') +box2d = subproject('box2d').get_variable('box2d_dep') + +assimp = subproject('assimp').get_variable('assimp_dep') + +dependencies += [ + glfw3, fuc2, fmt, glm, box2d, assimp +] + +inc_dirs = ['src'] + +sources = [ + 'glad/glad.cpp', + 'src/dbc.cpp', + 'src/stb_image.cpp', + 'src/shader.cpp', + 'src/physics.cpp', + 'src/mesh.cpp', + 'src/model.cpp', + 'src/camera.cpp', +] + +subdir('tests') + +executable('fuc2it', sources + fuc2_tests, + cpp_args: cpp_args, + link_args: link_args, + include_directories: inc_dirs, + override_options: exe_defaults, + dependencies: dependencies + [fuc2]) + +executable('hellogl', + sources + [ 'src/main.cpp' ], + cpp_args: cpp_args, + include_directories: inc_dirs, + link_args: link_args, + override_options: exe_defaults, + dependencies: dependencies) diff --git a/11-lightmaps/resources/textures/awesomeface.png b/11-lightmaps/resources/textures/awesomeface.png new file mode 100644 index 0000000000000000000000000000000000000000..9840caf3e7f4914ea1c6c15f688ffaf2cf44bae8 GIT binary patch literal 59277 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 Q0|5VhP*hj=DQ6!3fBcW&%>V!Z literal 0 HcmV?d00001 diff --git a/11-lightmaps/resources/textures/container.jpg b/11-lightmaps/resources/textures/container.jpg new file mode 100644 index 0000000000000000000000000000000000000000..d07bee4e3a679f5e2e4ad508ef3c4dc29a522492 GIT binary patch literal 184939 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

d`XyO#5L!x`fys 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[SQrQz8sg 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 literal 0 HcmV?d00001 diff --git a/11-lightmaps/resources/textures/popcorn.jpg b/11-lightmaps/resources/textures/popcorn.jpg new file mode 100644 index 0000000000000000000000000000000000000000..9f82106f468a6c55a285390b2603c58bafc6df8d GIT binary patch literal 6006 zcmeHHNlX+$6#doJ+w>4a!wf1OWYv)vGCjkv%!L4gK*R{*dK*-9JeYteXkr4mpq>Ob z^aQwo-cZ5iU_f!>hAZI3an}>LOQP+s2El^|^=Rr>>euV4|11AhRX=mkd;;Nxc?Eeu z2!VWTV20p(ZcVTppr{Cv06+yh0icM8P>YUC;Aw2a!fdUH$m8=M;JkAJ;|hreiREH% zCbK4S3vvAtZ?G)D9ifAGEbKts-4Fy3N0!@OE$pc zHoSg!y5F4|V`TV!Y5o*9R(}9M!5q=;@fa<_&s_y*p;H*w(agt?0|FigAVod`hus2`k3v9k>pnE=9x|S#o4?K#8kxcEJz3;}&Tet7@-@SML!NW&`L&Kq`&z`?{`RetXx1;agfB5+6^Ovtd0mIAy-1Kgj@-^ f5^^QvO30OvD>>>>>>>>>>>>>>>>>>>>> `date`" + if meson compile -C builddir + then + ./builddir/sfmldemo + else + echo "^^^^^^^^^^^^^^^^^^^^^ ERROR `date`" + fi +done diff --git a/11-lightmaps/scripts/windows_setup.ps1 b/11-lightmaps/scripts/windows_setup.ps1 new file mode 100644 index 0000000..73ed4d1 --- /dev/null +++ b/11-lightmaps/scripts/windows_setup.ps1 @@ -0,0 +1,255 @@ +function Test-WinUtilPackageManager { + <# + + .SYNOPSIS + Checks if Winget and/or Choco are installed + + .PARAMETER winget + Check if Winget is installed + + .PARAMETER choco + Check if Chocolatey is installed + + #> + + Param( + [System.Management.Automation.SwitchParameter]$winget, + [System.Management.Automation.SwitchParameter]$choco + ) + + $status = "not-installed" + + if ($winget) { + # Check if Winget is available while getting it's Version if it's available + $wingetExists = $true + try { + $wingetVersionFull = winget --version + } catch [System.Management.Automation.CommandNotFoundException], [System.Management.Automation.ApplicationFailedException] { + Write-Warning "Winget was not found due to un-availablity reasons" + $wingetExists = $false + } catch { + Write-Warning "Winget was not found due to un-known reasons, The Stack Trace is:`n$($psitem.Exception.StackTrace)" + $wingetExists = $false + } + + # If Winget is available, Parse it's Version and give proper information to Terminal Output. + # If it isn't available, the return of this funtion will be "not-installed", indicating that + # Winget isn't installed/available on The System. + if ($wingetExists) { + # Check if Preview Version + if ($wingetVersionFull.Contains("-preview")) { + $wingetVersion = $wingetVersionFull.Trim("-preview") + $wingetPreview = $true + } else { + $wingetVersion = $wingetVersionFull + $wingetPreview = $false + } + + # Check if Winget's Version is too old. + $wingetCurrentVersion = [System.Version]::Parse($wingetVersion.Trim('v')) + # Grabs the latest release of Winget from the Github API for version check process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $wingetLatestVersion = [System.Version]::Parse(($response.tag_name).Trim('v')) #Stores version number of latest release. + $wingetOutdated = $wingetCurrentVersion -lt $wingetLatestVersion + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Winget is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: $wingetVersionFull" -ForegroundColor White + + if (!$wingetPreview) { + Write-Host " - Winget is a release version." -ForegroundColor Green + } else { + Write-Host " - Winget is a preview version. Unexpected problems may occur." -ForegroundColor Yellow + } + + if (!$wingetOutdated) { + Write-Host " - Winget is Up to Date" -ForegroundColor Green + $status = "installed" + } + else { + Write-Host " - Winget is Out of Date" -ForegroundColor Red + $status = "outdated" + } + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Winget is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + if ($choco) { + if ((Get-Command -Name choco -ErrorAction Ignore) -and ($chocoVersion = (Get-Item "$env:ChocolateyInstall\choco.exe" -ErrorAction Ignore).VersionInfo.ProductVersion)) { + Write-Host "===========================================" -ForegroundColor Green + Write-Host "--- Chocolatey is installed ---" -ForegroundColor Green + Write-Host "===========================================" -ForegroundColor Green + Write-Host "Version: v$chocoVersion" -ForegroundColor White + $status = "installed" + } else { + Write-Host "===========================================" -ForegroundColor Red + Write-Host "--- Chocolatey is not installed ---" -ForegroundColor Red + Write-Host "===========================================" -ForegroundColor Red + $status = "not-installed" + } + } + + return $status +} + +function Get-WinUtilWingetPrerequisites { + <# + .SYNOPSIS + Downloads the Winget Prereqs. + .DESCRIPTION + Downloads Prereqs for Winget. Version numbers are coded as variables and can be updated as uncommonly as Microsoft updates the prereqs. + #> + + # I don't know of a way to detect the prereqs automatically, so if someone has a better way of defining these, that would be great. + # Microsoft.VCLibs version rarely changes, but for future compatibility I made it a variable. + $versionVCLibs = "14.00" + $fileVCLibs = "https://aka.ms/Microsoft.VCLibs.x64.${versionVCLibs}.Desktop.appx" + # Write-Host "$fileVCLibs" + # Microsoft.UI.Xaml version changed recently, so I made the version numbers variables. + $versionUIXamlMinor = "2.8" + $versionUIXamlPatch = "2.8.6" + $fileUIXaml = "https://github.com/microsoft/microsoft-ui-xaml/releases/download/v${versionUIXamlPatch}/Microsoft.UI.Xaml.${versionUIXamlMinor}.x64.appx" + # Write-Host "$fileUIXaml" + + Try{ + Write-Host "Downloading Microsoft.VCLibs Dependency..." + Invoke-WebRequest -Uri $fileVCLibs -OutFile $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx + Write-Host "Downloading Microsoft.UI.Xaml Dependency...`n" + Invoke-WebRequest -Uri $fileUIXaml -OutFile $ENV:TEMP\Microsoft.UI.Xaml.x64.appx + } + Catch{ + throw [WingetFailedInstall]::new('Failed to install prerequsites') + } +} + +function Get-WinUtilWingetLatest { + <# + .SYNOPSIS + Uses GitHub API to check for the latest release of Winget. + .DESCRIPTION + This function grabs the latest version of Winget and returns the download path to Install-WinUtilWinget for installation. + #> + # Invoke-WebRequest is notoriously slow when the byte progress is displayed. The following lines disable the progress bar and reset them at the end of the function + $PreviousProgressPreference = $ProgressPreference + $ProgressPreference = "silentlyContinue" + Try{ + # Grabs the latest release of Winget from the Github API for the install process. + $response = Invoke-RestMethod -Uri "https://api.github.com/repos/microsoft/Winget-cli/releases/latest" -Method Get -ErrorAction Stop + $latestVersion = $response.tag_name #Stores version number of latest release. + $licenseWingetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*License1.xml"} #Index value for License file. + Write-Host "Latest Version:`t$($latestVersion)`n" + Write-Host "Downloading..." + $assetUrl = $response.assets.browser_download_url | Where-Object {$_ -like "*Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"} + Invoke-WebRequest -Uri $licenseWingetUrl -OutFile $ENV:TEMP\License1.xml + # The only pain is that the msixbundle for winget-cli is 246MB. In some situations this can take a bit, with slower connections. + Invoke-WebRequest -Uri $assetUrl -OutFile $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle + } + Catch{ + throw [WingetFailedInstall]::new('Failed to get latest Winget release and license') + } + $ProgressPreference = $PreviousProgressPreference +} + +function Install-WinUtilWinget { + <# + + .SYNOPSIS + Installs Winget if it is not already installed. + + .DESCRIPTION + This function will download the latest version of Winget and install it. If Winget is already installed, it will do nothing. + #> + $isWingetInstalled = Test-WinUtilPackageManager -winget + + Try { + if ($isWingetInstalled -eq "installed") { + Write-Host "`nWinget is already installed.`r" -ForegroundColor Green + return + } elseif ($isWingetInstalled -eq "outdated") { + Write-Host "`nWinget is Outdated. Continuing with install.`r" -ForegroundColor Yellow + } else { + Write-Host "`nWinget is not Installed. Continuing with install.`r" -ForegroundColor Red + } + + # Gets the computer's information + if ($null -eq $sync.ComputerInfo){ + $ComputerInfo = Get-ComputerInfo -ErrorAction Stop + } else { + $ComputerInfo = $sync.ComputerInfo + } + + if (($ComputerInfo.WindowsVersion) -lt "1809") { + # Checks if Windows Version is too old for Winget + Write-Host "Winget is not supported on this version of Windows (Pre-1809)" -ForegroundColor Red + return + } + + # Install Winget via GitHub method. + # Used part of my own script with some modification: ruxunderscore/windows-initialization + Write-Host "Downloading Winget Prerequsites`n" + Get-WinUtilWingetPrerequisites + Write-Host "Downloading Winget and License File`r" + Get-WinUtilWingetLatest + Write-Host "Installing Winget w/ Prerequsites`r" + Add-AppxProvisionedPackage -Online -PackagePath $ENV:TEMP\Microsoft.DesktopAppInstaller.msixbundle -DependencyPackagePath $ENV:TEMP\Microsoft.VCLibs.x64.Desktop.appx, $ENV:TEMP\Microsoft.UI.Xaml.x64.appx -LicensePath $ENV:TEMP\License1.xml + Write-Host "Manually adding Winget Sources, from Winget CDN." + Add-AppxPackage -Path https://cdn.winget.microsoft.com/cache/source.msix #Seems some installs of Winget don't add the repo source, this should makes sure that it's installed every time. + Write-Host "Winget Installed" -ForegroundColor Green + Write-Host "Enabling NuGet and Module..." + Install-PackageProvider -Name NuGet -Force + Install-Module -Name Microsoft.WinGet.Client -Force + # Winget only needs a refresh of the environment variables to be used. + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + Write-Host "Failure detected while installing via GitHub method. Continuing with Chocolatey method as fallback." -ForegroundColor Red + # In case install fails via GitHub method. + Try { + # Install Choco if not already present + Install-WinUtilChoco + Start-Process -Verb runas -FilePath powershell.exe -ArgumentList "choco install winget-cli" + Write-Host "Winget Installed" -ForegroundColor Green + Write-Output "Refreshing Environment Variables...`n" + $ENV:PATH = [System.Environment]::GetEnvironmentVariable("Path", "Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path", "User") + } Catch { + throw [WingetFailedInstall]::new('Failed to install!') + } + } +} + + +$isAdmin = [System.Security.Principal.WindowsPrincipal]::new( + [System.Security.Principal.WindowsIdentity]::GetCurrent()). + IsInRole('Administrators') + +if(-not $isAdmin) { + $params = @{ + FilePath = 'powershell' # or pwsh if Core + Verb = 'RunAs' + ArgumentList = @( + '-ExecutionPolicy ByPass' + '-File "{0}"' -f $PSCommandPath + ) + } + + Start-Process -Wait @params + Write-Host "Admin stuff done..." +} else { + Write-Host "In Admin stuff..." + Install-WinUtilWinget + return +} + +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','chocolatey' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Git.Git' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.WindowsTerminal' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Python.Python.3.12' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','AntibodySoftware.WizFile' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Kitware.CMake' +Start-Process -NoNewWindow -Wait winget -ArgumentList 'install','Microsoft.VCRedist.2015+.x64' + +Start-Process -Verb RunAs -Wait powershell -argumentlist 'C:\ProgramData\chocolatey\bin\choco.exe','install','geany','geany-plugins','winlibs','conan','meson' diff --git a/11-lightmaps/shaders/08-frag.glsl b/11-lightmaps/shaders/08-frag.glsl new file mode 100644 index 0000000..5b3d816 --- /dev/null +++ b/11-lightmaps/shaders/08-frag.glsl @@ -0,0 +1,43 @@ +#version 330 core +struct Material { + vec3 ambient; + vec3 diffuse; + vec3 specular; + float shininess; +}; + +struct Light { + vec3 position; + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +uniform Light light; + +uniform Material material; +out vec4 FragColor; +in vec3 FragPos; +in vec3 Normal; + +uniform vec3 viewPos; + +void main() +{ + vec3 ambient = light.ambient * material.ambient; + + vec3 norm = normalize(Normal); + vec3 lightDir = normalize(light.position - FragPos); + float diff = max(dot(norm, lightDir), 0.0); + vec3 diffuse = light.diffuse * (diff * material.diffuse); + + vec3 viewDir = normalize(viewPos - FragPos); + vec3 reflectDir = reflect(-lightDir, norm); + + float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); + vec3 specular = light.specular * (material.specular * spec); + + vec3 result = ambient + diffuse + specular; + + FragColor = vec4(result, 1.0); +} diff --git a/11-lightmaps/shaders/08-lightsource.frag.glsl b/11-lightmaps/shaders/08-lightsource.frag.glsl new file mode 100644 index 0000000..c208aa1 --- /dev/null +++ b/11-lightmaps/shaders/08-lightsource.frag.glsl @@ -0,0 +1,16 @@ +#version 330 core +out vec4 FragColor; + +struct Light { + vec3 position; + vec3 ambient; + vec3 diffuse; + vec3 specular; +}; + +uniform Light light; + +void main() +{ + FragColor = vec4(light.diffuse, 1.0); // set all 4 vector values to 1.0 +} diff --git a/11-lightmaps/shaders/08-vert.glsl b/11-lightmaps/shaders/08-vert.glsl new file mode 100644 index 0000000..eda4400 --- /dev/null +++ b/11-lightmaps/shaders/08-vert.glsl @@ -0,0 +1,17 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec3 aNormal; + +out vec3 FragPos; +out vec3 Normal; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + FragPos = vec3(model * vec4(aPos, 1.0)); + Normal = mat3(transpose(inverse(model))) * aNormal; +} diff --git a/11-lightmaps/shaders/3.3.shader.fs b/11-lightmaps/shaders/3.3.shader.fs new file mode 100644 index 0000000..efe6832 --- /dev/null +++ b/11-lightmaps/shaders/3.3.shader.fs @@ -0,0 +1,8 @@ +#version 330 core +out vec4 FragColor; +in vec3 ourColor; + +void main() +{ + FragColor = vec4(ourColor, 1.0); +} diff --git a/11-lightmaps/shaders/3.3.shader.vs b/11-lightmaps/shaders/3.3.shader.vs new file mode 100644 index 0000000..21cf8d2 --- /dev/null +++ b/11-lightmaps/shaders/3.3.shader.vs @@ -0,0 +1,11 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 +layout (location = 1) in vec3 aColor; + +out vec3 ourColor; + +void main() +{ + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + ourColor = aColor; +} diff --git a/11-lightmaps/shaders/4.2.texture.fs b/11-lightmaps/shaders/4.2.texture.fs new file mode 100644 index 0000000..80ee6a7 --- /dev/null +++ b/11-lightmaps/shaders/4.2.texture.fs @@ -0,0 +1,11 @@ +#version 330 core + +out vec4 FragColor; +in vec2 TexCoord; + +uniform sampler2D texture1; + +void main() +{ + FragColor = texture(texture1, TexCoord); +} diff --git a/11-lightmaps/shaders/4.2.texture.vs b/11-lightmaps/shaders/4.2.texture.vs new file mode 100644 index 0000000..85c9de7 --- /dev/null +++ b/11-lightmaps/shaders/4.2.texture.vs @@ -0,0 +1,15 @@ +#version 330 core +layout (location = 0) in vec3 aPos; +layout (location = 1) in vec2 aTexCoord; + +out vec2 TexCoord; + +uniform mat4 model; +uniform mat4 view; +uniform mat4 projection; + +void main() +{ + gl_Position = projection * view * model * vec4(aPos, 1.0f); + TexCoord = vec2(aTexCoord.x, aTexCoord.y); +} diff --git a/11-lightmaps/src/camera.cpp b/11-lightmaps/src/camera.cpp new file mode 100644 index 0000000..1c456a7 --- /dev/null +++ b/11-lightmaps/src/camera.cpp @@ -0,0 +1,63 @@ +#include "camera.hpp" +#include +#include + +glm::mat4 Camera::lookAt() { + return glm::lookAt(pos, pos + front, up); +} + +void Camera::forward() { + pos += speed * front; +} + +void Camera::back() { + pos -= speed * front; +} + +void Camera::left() { + pos -= glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::right() { + pos += glm::normalize(glm::cross(front, up)) * speed; +} + +void Camera::update(float deltaTime) { + speed = movementSpeed * deltaTime; +} + +void Camera::mouse_move(double xpos, double ypos) { + if(firstMouse) { + lastX = xpos; + lastY = ypos; + firstMouse = false; + } + + float xoffset = xpos - lastX; + float yoffset = lastY - ypos; + lastX = xpos; + lastY = ypos; + + const float sensitivity = 0.1f; + xoffset *= sensitivity; + yoffset *= sensitivity; + + yaw += xoffset; + pitch += yoffset; + + if(pitch > 89.0f) pitch = 89.0f; + if(pitch < -89.0f) pitch = -89.0f; + + direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch)); + direction.y = sin(glm::radians(pitch)); + direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch)); + + front = glm::normalize(direction); +} + +void Camera::mouse_scroll(double xoffset, double yoffset) { + fov -= (float)yoffset; + + if(fov < 1.0f) fov = 1.0f; + if(fov > 90.0f) fov = 90.0f; +} diff --git a/11-lightmaps/src/camera.hpp b/11-lightmaps/src/camera.hpp new file mode 100644 index 0000000..91fe1f7 --- /dev/null +++ b/11-lightmaps/src/camera.hpp @@ -0,0 +1,27 @@ +#pragma once +#include + +struct Camera { + glm::vec3 pos = glm::vec3(0.0f, 0.0f, 3.0f); + glm::vec3 front = glm::vec3(0.0f, 0.0f, -1.0f); + glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f); + glm::vec3 direction = glm::vec3(0.0f, 0.0f, 0.0f); + float movementSpeed = 20.0f; + + float pitch = 0.0f; + float yaw = -90.0f; + float speed = 0.05f; + float lastX = 400; + float lastY = 300; + float fov = 45.0f; + bool firstMouse = true; + + glm::mat4 lookAt(); + void forward(); + void back(); + void left(); + void right(); + void update(float deltaTime); + void mouse_move(double xpos, double ypos); + void mouse_scroll(double xoffset, double yoffset); +}; diff --git a/11-lightmaps/src/data.hpp b/11-lightmaps/src/data.hpp new file mode 100644 index 0000000..83245f2 --- /dev/null +++ b/11-lightmaps/src/data.hpp @@ -0,0 +1,46 @@ +#pragma once +#include + +float vertices[] = { + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + -0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f, + + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + -0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f, + + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f, + + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f, + + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + 0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + -0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f, + -0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f, + + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + 0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, + -0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f +}; diff --git a/11-lightmaps/src/dbc.cpp b/11-lightmaps/src/dbc.cpp new file mode 100644 index 0000000..63e3aeb --- /dev/null +++ b/11-lightmaps/src/dbc.cpp @@ -0,0 +1,47 @@ +#include "dbc.hpp" +#include + +void dbc::log(const string &message, const std::source_location location) { + std::cout << '[' << location.file_name() << ':' + << location.line() << "|" + << location.function_name() << "] " + << message << std::endl; +} + +void dbc::sentinel(const string &message, const std::source_location location) { + string err = $F("[SENTINEL!] {}", message); + dbc::log(err, location); + throw dbc::SentinelError(err); +} + +void dbc::pre(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[PRE!] {}", message); + dbc::log(err, location); + throw dbc::PreCondError(err); + } +} + +void dbc::pre(const string &message, std::function tester, const std::source_location location) { + dbc::pre(message, tester(), location); +} + +void dbc::post(const string &message, bool test, const std::source_location location) { + if(!test) { + string err = $F("[POST!] {}", message); + dbc::log(err, location); + throw dbc::PostCondError(err); + } +} + +void dbc::post(const string &message, std::function tester, const std::source_location location) { + dbc::post(message, tester(), location); +} + +void dbc::check(bool test, const string &message, const std::source_location location) { + if(!test) { + string err = $F("[CHECK!] {}\n", message); + dbc::log(err, location); + throw dbc::CheckError(err); + } +} diff --git a/11-lightmaps/src/dbc.hpp b/11-lightmaps/src/dbc.hpp new file mode 100644 index 0000000..4b17b71 --- /dev/null +++ b/11-lightmaps/src/dbc.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include +#include +#include + +// AKA the Fuckit macro +#define $F(FMT, ...) fmt::format(FMT, ##__VA_ARGS__) + +namespace dbc { + using std::string; + + using CheckError = std::runtime_error; + using SentinelError = std::runtime_error; + using PreCondError = std::runtime_error; + using PostCondError = std::runtime_error; + + void log(const string &message, + const std::source_location location = + std::source_location::current()); + + [[noreturn]] void sentinel(const string &message, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void pre(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, bool test, + const std::source_location location = + std::source_location::current()); + + void post(const string &message, std::function tester, + const std::source_location location = + std::source_location::current()); + + void check(bool test, const string &message, + const std::source_location location = + std::source_location::current()); +} diff --git a/11-lightmaps/src/main.cpp b/11-lightmaps/src/main.cpp new file mode 100644 index 0000000..42e8237 --- /dev/null +++ b/11-lightmaps/src/main.cpp @@ -0,0 +1,334 @@ +#define _USE_MATH_DEFINES +#include +#include "dbc.hpp" +#include +#include +#include +#include +#include +#include "shader.hpp" +#include +#include +#include +#include +#include "data.hpp" +#include "physics.hpp" +#include "model.hpp" +#include "camera.hpp" + +void framebuffer_size_callback(GLFWwindow *window, int width, int height); +void processInput(GLFWwindow *window); + +const unsigned int SCR_WIDTH = 800; +const unsigned int SCR_HEIGHT = 600; + +struct Config { + Shader shader; + Shader lightShader; + Model model; + + Light light{ + .position={1.2f, 1.0f, 2.0f}, + .ambient={0.2f, 0.2f, 0.2f}, + .diffuse={0.8f, 0.8f, 0.8f}, + .specular={1.0f, 1.0f, 1.0f}, + }; + + glm::vec3 boxPos{2.0f, 0.0f, 0.0f}; + unsigned int cubeVAO = 0; + unsigned int lightCubeVAO = 0; + unsigned int VBO = 0; + Camera camera{.movementSpeed=2.0f}; + float deltaTime = 0.0f; + float lastFrame = 0.0f; + + void updateDelta() { + float currentFrame = glfwGetTime(); + deltaTime = currentFrame - lastFrame; + lastFrame = currentFrame; + } +}; + +void init_glfw() { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); +} + +void framebuffer_size_callback(GLFWwindow *, int width, int height) { + glViewport(0, 0, width, height); +} + +void mouse_callback(GLFWwindow *window, double xpos, double ypos) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_move(xpos, ypos); +} + +void scroll_callback(GLFWwindow *window, double xoffset, double yoffset) { + Camera* camera = static_cast(glfwGetWindowUserPointer(window)); + camera->mouse_scroll(xoffset, yoffset); +} + +GLFWwindow* create_window() { + GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL); + dbc::check(window != NULL, "failed to open window"); + + glfwMakeContextCurrent(window); + + glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); + + auto good = gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); + dbc::check(good, "failed to load GLAD"); + + glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); + glfwSetCursorPosCallback(window, mouse_callback); + glfwSetScrollCallback(window, scroll_callback); + + return window; +} + + +void processInput(GLFWwindow *window, BoxTest &box, Camera& camera) { + + if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(window, true); + } + + if(glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) { + b2Vec2 force(0.0f, 0.5f); + for(size_t i = 0; i < BODY_COUNT; i++) { + box.bodies[i]->ApplyForceToCenter(force, true); + box.bodies[i]->ApplyTorque(0.1f, true); + } + } + + if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) { + camera.forward(); + } + + if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) { + camera.back(); + } + + if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) { + camera.left(); + } + + if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) { + camera.right(); + } +} + +unsigned int load_texture(const std::string& image_file) { + unsigned int texture_id; + glGenTextures(1, &texture_id); + glBindTexture(GL_TEXTURE_2D, texture_id); + + // set the texture wrapping parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + + // set texture filtering parameters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + int width = 0; + int height = 0; + int nrChannels = 0; + stbi_set_flip_vertically_on_load(true); + + unsigned char *data = stbi_load(image_file.c_str(), &width, &height, &nrChannels, 0); + + dbc::check(data != nullptr, std::format("Failed to load texture: {}", image_file)); + + dbc::check(nrChannels == 3 || nrChannels == 4, + std::format("Image {} has invalid channels {} should be 3 or 4.", image_file, nrChannels)); + + auto rgb_or_a = nrChannels == 3 ? GL_RGB : GL_RGBA; + + glTexImage2D(GL_TEXTURE_2D, 0, rgb_or_a, width, height, 0, rgb_or_a, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + stbi_image_free(data); + + return texture_id; +} + +Config setup() { + glEnable(GL_DEPTH_TEST); + + Config config{ + .shader={"shaders/08-vert.glsl", "shaders/08-frag.glsl"}, + .lightShader={"shaders/08-vert.glsl", "shaders/08-lightsource.frag.glsl"}, + .model={"assets/popcorn_model_a.glb"} + }; + + unsigned int VBO = 0; + unsigned int lightCubeVAO = 0; + unsigned int cubeVAO = 0; + + // cube vao configure, this is the light target + glGenVertexArrays(1, &cubeVAO); + glGenBuffers(1, &VBO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); + + glBindVertexArray(cubeVAO); + + // position attribute + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0); + glEnableVertexAttribArray(0); + + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)(3 * sizeof(float))); + glEnableVertexAttribArray(1); + + // light vao configure, this is the light source + glGenVertexArrays(1, &lightCubeVAO); + glBindVertexArray(lightCubeVAO); + + glBindBuffer(GL_ARRAY_BUFFER, VBO); + + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); + glEnableVertexAttribArray(0); + + config.lightCubeVAO = lightCubeVAO; + config.cubeVAO = cubeVAO; + config.VBO = VBO; + + return config; +} + +void draw_popcorn(Config& config, BoxTest& box, size_t box_i, glm::mat4& projection, glm::mat4& view) +{ + config.shader.use(); + + config.shader.setMat4("view", view); + config.shader.setMat4("projection", projection); + config.shader.setVec3("viewPos", config.camera.pos); + + config.shader.applyLight(config.light); + + glm::vec3 objectColor = {1.0, 0.94, 0.78}; + config.shader.applyMaterial({ + .ambient = objectColor, + .diffuse = objectColor, + .specular = objectColor, + .shininess = 100000.0f}); + + float time = glfwGetTime(); + // get position from box + b2Vec2 position = box.bodies[box_i]->GetPosition(); + float angle = box.bodies[box_i]->GetAngle(); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, glm::vec3(position.x, position.y, 0.0f)); + + model = glm::rotate(model, angle / 5.0f, glm::vec3(1.0f, 0.0f, 0.0f)); + model = glm::rotate(model, glm::radians(time * 10.0f), glm::vec3(0.0f, 1.0f, 1.0f)); + + config.shader.setMat4("model", model); + + config.model.Draw(config.shader); +} + +void draw_cube(Config& config, glm::mat4& projection, glm::mat4& view) { + config.shader.use(); + + config.shader.applyLight(config.light); + + config.shader.setMat4("view", view); + config.shader.setMat4("projection", projection); + config.shader.setVec3("viewPos", config.camera.pos); + config.shader.applyMaterial({ + .ambient = {1.0f, 0.5f, 0.31f}, + .diffuse = {1.0f, 0.5f, 0.31f}, + .specular = config.light.specular, + .shininess = 32.0f}); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, config.boxPos); + config.shader.setMat4("model", model); + glBindVertexArray(config.cubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); +} + +void draw_light(Config& config, glm::mat4& projection, glm::mat4& view) { + config.lightShader.use(); + + config.lightShader.applyLight(config.light); + config.lightShader.setMat4("projection", projection); + config.lightShader.setMat4("view", view); + + glm::mat4 model = glm::mat4(1.0f); + model = glm::translate(model, config.light.position); + model = glm::scale(model, glm::vec3(0.2f)); + config.lightShader.setMat4("model", model); + + glBindVertexArray(config.lightCubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); +} + + +void render(GLFWwindow* window, Config& config, BoxTest& box, b2World& world) { + glClearColor(0.1f, 0.1f, 0.1f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + config.shader.use(); + + Box2d_step_world(world); + + // time is used for fake 3d rotation + float time = glfwGetTime(); + + config.camera.update(config.deltaTime); + + glm::mat4 view = config.camera.lookAt(); + glm::mat4 projection = glm::mat4(1.0f); + // fov, aspect, near plane, far plane + projection = glm::perspective(glm::radians(config.camera.fov), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); + + // update light color + draw_cube(config, projection, view); + + // the 0 is for which popcorn, so later when we have N for-loop + draw_popcorn(config, box, 0, projection, view); + + draw_light(config, projection, view); + + glfwSwapBuffers(window); + glfwPollEvents(); +} + +void cleanup(Config& config) { + glDeleteVertexArrays(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.lightCubeVAO); + glDeleteBuffers(1, &config.VBO); + config.shader.cleanup(); +} + +int main() { + init_glfw(); + + b2Vec2 gravity(0.0f, -10.0f); + b2World world(gravity); + BoxTest box = Box2d_setup(world); + + auto window = create_window(); + auto config = setup(); + + glfwSetWindowUserPointer(window, &config.camera); + + while(!glfwWindowShouldClose(window)) { + processInput(window, box, config.camera); + render(window, config, box, world); + config.updateDelta(); + } + + cleanup(config); + + glfwTerminate(); + + return 0; +} diff --git a/11-lightmaps/src/mesh.cpp b/11-lightmaps/src/mesh.cpp new file mode 100644 index 0000000..a05e18b --- /dev/null +++ b/11-lightmaps/src/mesh.cpp @@ -0,0 +1,57 @@ +#include "mesh.hpp" + +void Mesh::Draw(Shader &shader) { + unsigned int diffuseNr = 1; + unsigned int specularNr = 1; + unsigned int normalNr = 1; + unsigned int heightNr = 1; + + for(unsigned int i = 0; i < textures.size(); i++) { + glActiveTexture(GL_TEXTURE0 + i); + std::string number; + std::string name = textures[i].type; + + if(name == "texture_diffuse") { + number = std::to_string(diffuseNr++); + } else if(name == "texture_specular") { + number = std::to_string(specularNr++); + } else if(name == "texture_normal") { + number = std::to_string(normalNr++); + } else if(name == "texture_height") { + number = std::to_string(heightNr++); + } + + // TODO: Get this uniform ID once and cache it? + glUniform1i(glGetUniformLocation(shader.ID, (name + number).c_str()), i); + glBindTexture(GL_TEXTURE_2D, textures[i].id); + } + + glBindVertexArray(VAO); + glDrawElements(GL_TRIANGLES, static_cast(indices.size()), GL_UNSIGNED_INT, 0); + glBindVertexArray(0); + + glActiveTexture(GL_TEXTURE0); +} + + +void Mesh::setupMesh() { + glGenVertexArrays(1, &VAO); + glGenBuffers(1, &VBO); + glGenBuffers(1, &EBO); + + glBindVertexArray(VAO); + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW); + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW); + + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Position)); + + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, Normal)); + + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, TexCoords)); +} diff --git a/11-lightmaps/src/mesh.hpp b/11-lightmaps/src/mesh.hpp new file mode 100644 index 0000000..50b515d --- /dev/null +++ b/11-lightmaps/src/mesh.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +#include "shader.hpp" + +#include +#include + +struct Vertex { + glm::vec3 Position; + glm::vec3 Normal; + glm::vec2 TexCoords; +}; + +struct Texture { + unsigned int id; + std::string type; + std::string path; +}; + +struct Mesh { + std::vector vertices; + std::vector indices; + std::vector textures; + unsigned int VAO; + unsigned int VBO; + unsigned int EBO; + + Mesh(std::vector vertices, std::vector indices, std::vector textures) : + vertices(vertices), + indices(indices), + textures(textures) + { + setupMesh(); + } + + void Draw(Shader &shader); + void setupMesh(); +}; diff --git a/11-lightmaps/src/model.cpp b/11-lightmaps/src/model.cpp new file mode 100644 index 0000000..e6b2fdd --- /dev/null +++ b/11-lightmaps/src/model.cpp @@ -0,0 +1,171 @@ +#include "model.hpp" +#include "dbc.hpp" + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma) +{ + std::string filename = path + "/" + filename; + + unsigned int textureID; + glGenTextures(1, &textureID); + + int width = 0; + int height = 0; + int nrComponents = 0; + + unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0); + dbc::check(data != nullptr, $F("Failed to load texture {}", filename)); + + GLenum format = GL_RGB; + + if (nrComponents == 1) { + format = GL_RED; + } else if (nrComponents == 3) { + format = GL_RGB; + } else if (nrComponents == 4) { + format = GL_RGBA; + } + + glBindTexture(GL_TEXTURE_2D, textureID); + glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); + glGenerateMipmap(GL_TEXTURE_2D); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + + stbi_image_free(data); + + return textureID; +} + +void Model::Draw(Shader &shader) { + for(unsigned int i = 0; i < meshes.size(); i++) { + meshes[i].Draw(shader); + } +} + +void Model::loadModel(std::string path) { + Assimp::Importer importer; + const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); + + dbc::check(scene != nullptr, "Assimp ReadFile return null"); + dbc::check(!(scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE), "Assimp says incomplete."); + dbc::check(scene->mRootNode != nullptr, "Assimp loaded scene doesn't have a root node"); + + directory = path.substr(0, path.find_last_of('/')); + + processNode(scene->mRootNode, scene); +} + +void Model::processNode(aiNode *node, const aiScene *scene) { + for(unsigned int i = 0; i < node->mNumMeshes; i++) { + aiMesh* mesh = scene->mMeshes[node->mMeshes[i]]; + meshes.push_back(processMesh(mesh, scene)); + } + + for(unsigned int i = 0; i < node->mNumChildren; i++) { + processNode(node->mChildren[i], scene); + } +} + +Mesh Model::processMesh(aiMesh *mesh, const aiScene *scene) { + std::vector vertices; + std::vector indices; + std::vector textures; + + for(unsigned int i = 0; i < mesh->mNumVertices; i++) { + Vertex vertex; + vertex.Position = glm::vec3( + mesh->mVertices[i].x, + mesh->mVertices[i].y, + mesh->mVertices[i].z); + + if(mesh->HasNormals()) { + vertex.Normal = glm::vec3( + mesh->mNormals[i].x, + mesh->mNormals[i].y, + mesh->mNormals[i].z); + } + + if(mesh->mTextureCoords[0]) { + vertex.TexCoords = glm::vec2( + mesh->mTextureCoords[0][i].x, + mesh->mTextureCoords[0][i].y + ); + } else { + vertex.TexCoords = glm::vec2(0.0f, 0.0f); + } + + vertices.push_back(vertex); + } + + for(unsigned int i = 0; i < mesh->mNumFaces; i++) { + aiFace face = mesh->mFaces[i]; + + for(unsigned int j = 0; j < face.mNumIndices; j++) { + indices.push_back(face.mIndices[j]); + } + } + + aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex]; + + // we assume a convention for sampler names in the shaders. Each diffuse texture should be named + // as 'texture_diffuseN' where N is a sequential number ranging from 1 to MAX_SAMPLER_NUMBER. + // Same applies to other texture as the following list summarizes: + // diffuse: texture_diffuseN + // specular: texture_specularN + // normal: texture_normalN + + // 1. diffuse maps + std::vector diffuseMaps = loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse"); + textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); + + // 2. specular maps + std::vector specularMaps = loadMaterialTextures(material, aiTextureType_SPECULAR, "texture_specular"); + textures.insert(textures.end(), specularMaps.begin(), specularMaps.end()); + + // 3. normal maps + std::vector normalMaps = loadMaterialTextures(material, aiTextureType_HEIGHT, "texture_normal"); + textures.insert(textures.end(), normalMaps.begin(), normalMaps.end()); + + // 4. height maps + std::vector heightMaps = loadMaterialTextures(material, aiTextureType_AMBIENT, "texture_height"); + textures.insert(textures.end(), heightMaps.begin(), heightMaps.end()); + + return Mesh(vertices, indices, textures); +} + +std::vector Model::loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName) +{ + fmt::println("TEXTURE COUNT: {}, {}, {}", (int)type, typeName, mat->GetTextureCount(type)); + + std::vector textures; + for(unsigned int i = 0; i < mat->GetTextureCount(type); i++) { + aiString str; + mat->GetTexture(type, i, &str); + std::string tx_str{str.C_Str()}; + + bool skip = false; + for(unsigned int j = 0; j < textures_loaded.size(); j++) { + if(textures_loaded[j].path == tx_str) { + textures.push_back(textures_loaded[j]); + skip = true; + break; + } + } + + if(!skip) { + Texture texture{ + .id = TextureFromFile(tx_str, directory), + .type = typeName, + .path = tx_str, + }; + + textures.push_back(texture); + textures_loaded.push_back(texture); + } + } + + return textures; +} diff --git a/11-lightmaps/src/model.hpp b/11-lightmaps/src/model.hpp new file mode 100644 index 0000000..8d23203 --- /dev/null +++ b/11-lightmaps/src/model.hpp @@ -0,0 +1,40 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +unsigned int TextureFromFile(const std::string& path, const std::string& directory, bool gamma = false); + +struct Model { + std::vector textures_loaded; + std::vector meshes; + std::string directory; + bool gammaCorrection; + + Model(const char *path) { + loadModel(path); + } + + void Draw(Shader &shader); + + void loadModel(std::string path); + void processNode(aiNode *node, const aiScene *scene); + Mesh processMesh(aiMesh *mesh, const aiScene *scene); + + std::vector loadMaterialTextures(aiMaterial *mat, aiTextureType type, std::string typeName); +}; diff --git a/11-lightmaps/src/physics.cpp b/11-lightmaps/src/physics.cpp new file mode 100644 index 0000000..daa8f87 --- /dev/null +++ b/11-lightmaps/src/physics.cpp @@ -0,0 +1,49 @@ +#include "physics.hpp" + +struct BoxTest Box2d_setup(b2World &world) { + BoxTest box; + float wall_x[4] = {0.0f, 0.0f, -0.99f, 0.99f}; + float wall_y[4] = {-0.99, 0.99f, 0.0f, 0.0f}; + float bound_w[4] = {1.0f, 1.0f, 0.1f, 0.1f}; + float bound_h[4] = {0.1f, 0.1f, 1.0f, 1.0f}; + + for(size_t i = 0; i < 4; i++) { + b2BodyDef groundBodyDef; + groundBodyDef.position.Set(wall_x[i], wall_y[i]); + b2Body *groundBody = world.CreateBody(&groundBodyDef); + + b2PolygonShape groundBox; + groundBox.SetAsBox(bound_w[i], bound_h[i]); + groundBody->CreateFixture(&groundBox, 1.0f); + + box.walls[i] = groundBody; + } + + for(size_t i = 0; i < BODY_COUNT; i++) { + b2BodyDef bodyDef; + bodyDef.type = b2_dynamicBody; + bodyDef.position.Set(0.0f, 0.5f); + box.bodies[i] = world.CreateBody(&bodyDef); + + b2PolygonShape dynamicBox; + dynamicBox.SetAsBox(0.1f, 0.1f); + b2FixtureDef fixtureDef; + fixtureDef.shape = &dynamicBox; + + fixtureDef.density = 1.0f; + fixtureDef.friction = 0.3f; + + box.bodies[i]->CreateFixture(&fixtureDef); + } + + return box; +} + +void Box2d_step_world(b2World& world) { + float timeStep = 1.0f / 60.0f; + int velocityIterations = 6; + int positionIterations = 2; + + // step the world + world.Step(timeStep, velocityIterations, positionIterations); +} diff --git a/11-lightmaps/src/physics.hpp b/11-lightmaps/src/physics.hpp new file mode 100644 index 0000000..dc98a31 --- /dev/null +++ b/11-lightmaps/src/physics.hpp @@ -0,0 +1,13 @@ +#pragma once + +#include + +#define BODY_COUNT 1 + +struct BoxTest { + b2Body *walls[4]; + b2Body *bodies[BODY_COUNT]; +}; + +struct BoxTest Box2d_setup(b2World &world); +void Box2d_step_world(b2World& world); diff --git a/11-lightmaps/src/shader.cpp b/11-lightmaps/src/shader.cpp new file mode 100644 index 0000000..a89af73 --- /dev/null +++ b/11-lightmaps/src/shader.cpp @@ -0,0 +1,126 @@ +#include "shader.hpp" +#include +#include +#include +#include +#include +#include "dbc.hpp" +#include +#include +#include + +namespace fs = std::filesystem; + +inline std::string read_file(const std::string& filename) { + // load the file + std::ifstream in_file{filename, std::ios::binary}; + + // get the size of the file + std::stringstream in_str; + in_str << in_file.rdbuf(); + return in_str.str(); +} + +void check_error(const std::string& what, unsigned int thing, GLenum check_type) { + int success = 0; + char infoLog[512] = {0}; + + if(check_type == GL_LINK_STATUS) { + glGetProgramiv(thing, check_type, &success); + + if(!success) { + glGetProgramInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Program {} compile failed: {}", what, infoLog)); + } + } else { + glGetShaderiv(thing, check_type, &success); + + if(!success) { + glGetShaderInfoLog(thing, 512, NULL, infoLog); + dbc::sentinel(std::format("ERROR: Shader {} compile failed: {}", what, infoLog)); + } + } +} + +unsigned int Shader::load_shader(const std::string& filename, GLenum shader_type) { + dbc::check(fs::exists(filename), + std::format("shader file {} does not exist", filename)); + + // create the shader + std::string shader_code = read_file(filename); + const char* shader_code_ptr = shader_code.c_str(); + + int shader_id = glCreateShader(shader_type); + glShaderSource(shader_id, 1, &shader_code_ptr, NULL); + glCompileShader(shader_id); + + check_error(filename, shader_id, GL_COMPILE_STATUS); + + // check compile error + return shader_id; +} + +Shader::Shader(const char* vertexPath, const char* fragmentPath) { + unsigned int vertex = load_shader(vertexPath, GL_VERTEX_SHADER); + unsigned int fragment = load_shader(fragmentPath, GL_FRAGMENT_SHADER); + + ID = glCreateProgram(); + glAttachShader(ID, vertex); + glAttachShader(ID, fragment); + glLinkProgram(ID); + + check_error("link", ID, GL_LINK_STATUS); + + glDeleteShader(vertex); + glDeleteShader(fragment); +} + +void Shader::use() const { + glUseProgram(ID); +} + +void Shader::cleanup() { + glDeleteProgram(ID); +} + +void Shader::setBool(const std::string &name, bool value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, (int)value); +} + +void Shader::setInt(const std::string &name, int value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1i(uniform, value); +} + +void Shader::setFloat(const std::string &name, float value) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform1f(uniform, value); +} + +void Shader::setVec4(const std::string &name, float v1, float v2, float v3, float v4) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4f(uniform, v1, v2, v3, v4); +} + +void Shader::setVec4(const std::string &name, const glm::vec4& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform4fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, const glm::vec3& value) const +{ + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3fv(uniform, 1, &value[0]); +} + +void Shader::setVec3(const std::string &name, float v1, float v2, float v3) const { + auto uniform = glGetUniformLocation(ID, name.c_str()); + glUniform3f(uniform, v1, v2, v3); +} + +void Shader::setMat4(const std::string &name, const glm::mat4& mat) const { + unsigned int loc = glGetUniformLocation(ID, name.c_str()); + glUniformMatrix4fv(loc, 1, GL_FALSE, glm::value_ptr(mat)); +} diff --git a/11-lightmaps/src/shader.hpp b/11-lightmaps/src/shader.hpp new file mode 100644 index 0000000..947a7f9 --- /dev/null +++ b/11-lightmaps/src/shader.hpp @@ -0,0 +1,53 @@ +#pragma once + +#include +#include +#include +#include + +struct Material { + glm::vec3 ambient{0.1f,0.1f,0.1f}; + glm::vec3 diffuse{0.5f,0.5f,0.5f}; + glm::vec3 specular{0.8f, 0.8f, 0.8f}; + float shininess{32.0f}; +}; + +struct Light { + glm::vec3 position; + glm::vec3 ambient; + glm::vec3 diffuse; + glm::vec3 specular; +}; + +class Shader +{ +public: + unsigned int ID = UINT_MAX; + + Shader(const char* vertexPath, const char* fragmentPath); + unsigned int load_shader(const std::string& filename, GLenum shader_type); + void use() const; + void setBool(const std::string &name, bool value) const; + void setInt(const std::string &name, int value) const; + void setFloat(const std::string &name, float value) const; + void setVec4(const std::string &name, float v1, float v2, float v3, float v4) const; + void setVec4(const std::string &name, const glm::vec4& value) const; + void setVec3(const std::string &name, float v1, float v2, float v3) const; + void setVec3(const std::string &name, const glm::vec3& value) const; + void setMat4(const std::string &name, const glm::mat4& what) const; + void cleanup(); + + void applyMaterial(const Material& material) { + setVec3("material.ambient", material.ambient); + setVec3("material.diffuse", material.diffuse); + setVec3("material.specular", material.specular); + setFloat("material.shininess", material.shininess); + } + + void applyLight(const Light& light) { + setVec3("light.position", light.position); + setVec3("light.ambient", light.ambient); + setVec3("light.diffuse", light.diffuse); + setVec3("light.specular", light.specular); + } +}; diff --git a/11-lightmaps/src/stb_image.cpp b/11-lightmaps/src/stb_image.cpp new file mode 100644 index 0000000..9177288 --- /dev/null +++ b/11-lightmaps/src/stb_image.cpp @@ -0,0 +1,2 @@ +#define STB_IMAGE_IMPLEMENTATION +#include diff --git a/11-lightmaps/src/stb_image.h b/11-lightmaps/src/stb_image.h new file mode 100644 index 0000000..9eedabe --- /dev/null +++ b/11-lightmaps/src/stb_image.h @@ -0,0 +1,7988 @@ +/* stb_image - v2.30 - public domain image loader - http://nothings.org/stb + no warranty implied; use at your own risk + + Do this: + #define STB_IMAGE_IMPLEMENTATION + before you include this file in *one* C or C++ file to create the implementation. + + // i.e. it should look like this: + #include ... + #include ... + #include ... + #define STB_IMAGE_IMPLEMENTATION + #include "stb_image.h" + + You can #define STBI_ASSERT(x) before the #include to avoid using assert.h. + And #define STBI_MALLOC, STBI_REALLOC, and STBI_FREE to avoid using malloc,realloc,free + + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline & progressive (12 bpc/arithmetic not supported, same as stock IJG lib) + PNG 1/2/4/8/16-bit-per-channel + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels, 8/16 bit-per-channel) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + PNM (PPM and PGM binary only) + + Animated GIF still needs a proper API, but here's one way to do it: + http://gist.github.com/urraka/685d9a6340b26b830d49 + + - decode from memory or through FILE (define STBI_NO_STDIO to remove code) + - decode from arbitrary I/O callbacks + - SIMD acceleration on x86/x64 (SSE2) and ARM (NEON) + + Full documentation under "DOCUMENTATION" below. + + +LICENSE + + See end of file for license information. + +RECENT REVISION HISTORY: + + 2.30 (2024-05-31) avoid erroneous gcc warning + 2.29 (2023-05-xx) optimizations + 2.28 (2023-01-29) many error fixes, security errors, just tons of stuff + 2.27 (2021-07-11) document stbi_info better, 16-bit PNM support, bug fixes + 2.26 (2020-07-13) many minor fixes + 2.25 (2020-02-02) fix warnings + 2.24 (2020-02-02) fix warnings; thread-local failure_reason and flip_vertically + 2.23 (2019-08-11) fix clang static analysis warning + 2.22 (2019-03-04) gif fixes, fix warnings + 2.21 (2019-02-25) fix typo in comment + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) bugfix, 1-bit BMP, 16-bitness query, fix warnings + 2.16 (2017-07-23) all functions have 16-bit variants; optimizations; bugfixes + 2.15 (2017-03-18) fix png-1,2,4; all Imagenet JPGs; no runtime SSE detection on GCC + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-12-04) experimental 16-bit API, only for PNG so far; fixes + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) 16-bit PNGS; enable SSE2 in non-gcc x64 + RGB-format JPEG; remove white matting in PSD; + allocate large structures on the stack; + correct channel count for PNG & BMP + 2.10 (2016-01-22) avoid warning introduced in 2.09 + 2.09 (2016-01-16) 16-bit TGA; comments in PNM files; STBI_REALLOC_SIZED + + See end of file for full revision history. + + + ============================ Contributors ========================= + + Image formats Extensions, features + Sean Barrett (jpeg, png, bmp) Jetro Lauha (stbi_info) + Nicolas Schulz (hdr, psd) Martin "SpartanJ" Golini (stbi_info) + Jonathan Dummer (tga) James "moose2000" Brown (iPhone PNG) + Jean-Marc Lienher (gif) Ben "Disch" Wenger (io callbacks) + Tom Seddon (pic) Omar Cornut (1/2/4-bit PNG) + Thatcher Ulrich (psd) Nicolas Guillemot (vertical flip) + Ken Miller (pgm, ppm) Richard Mitton (16-bit PSD) + github:urraka (animated gif) Junggon Kim (PNM comments) + Christopher Forseth (animated gif) Daniel Gibson (16-bit TGA) + socks-the-fox (16-bit PNG) + Jeremy Sawicki (handle all ImageNet JPGs) + Optimizations & bugfixes Mikhail Morozov (1-bit BMP) + Fabian "ryg" Giesen Anael Seghezzi (is-16-bit query) + Arseny Kapoulkine Simon Breuss (16-bit PNM) + John-Mark Allen + Carmelo J Fdez-Aguera + + Bug & warning fixes + Marc LeBlanc David Woo Guillaume George Martins Mozeiko + Christpher Lloyd Jerry Jansson Joseph Thomson Blazej Dariusz Roszkowski + Phil Jordan Dave Moore Roy Eltham + Hayaki Saito Nathan Reed Won Chun + Luke Graham Johan Duparc Nick Verigakis the Horde3D community + Thomas Ruf Ronny Chevalier github:rlyeh + Janez Zemva John Bartholomew Michal Cichon github:romigrou + Jonathan Blow Ken Hamada Tero Hanninen github:svdijk + Eugene Golushkov Laurent Gomila Cort Stratton github:snagar + Aruelien Pocheville Sergio Gonzalez Thibault Reuille github:Zelex + Cass Everitt Ryamond Barbiero github:grim210 + Paul Du Bois Engin Manap Aldo Culquicondor github:sammyhw + Philipp Wiesemann Dale Weiler Oriol Ferrer Mesia github:phprus + Josh Tobin Neil Bickford Matthew Gregan github:poppolopoppo + Julian Raschke Gregory Mullen Christian Floisand github:darealshinji + Baldur Karlsson Kevin Schmidt JR Smith github:Michaelangel007 + Brad Weinberger Matvey Cherevko github:mosra + Luca Sas Alexander Veselov Zack Middleton [reserved] + Ryan C. Gordon [reserved] [reserved] + DO NOT ADD YOUR NAME HERE + + Jacko Dirks + + To add your name to the credits, pick a random blank space in the middle and fill it. + 80% of merge conflicts on stb PRs are due to people adding their name at the end + of the credits. +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// DOCUMENTATION +// +// Limitations: +// - no 12-bit-per-channel JPEG +// - no JPEGs with arithmetic coding +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below for HDR usage): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// // ... but 'n' will always be the number that it would have been if you said 0 +// stbi_image_free(data); +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *channels_in_file -- outputs # of image components in image file +// int desired_channels -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data, or NULL on an allocation failure or if the image is +// corrupt or invalid. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'desired_channels' if desired_channels is non-zero, or +// *channels_in_file otherwise. If desired_channels is non-zero, +// *channels_in_file has the number of components that _would_ have been +// output otherwise. E.g. if you set desired_channels to 4, you will always +// get RGBA output, but you can check *channels_in_file to see if it's trivially +// opaque because e.g. there were only 3 channels in the source image. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *channels_in_file will be unchanged. The function +// stbi_failure_reason() can be queried for an extremely brief, end-user +// unfriendly explanation of why the load failed. Define STBI_NO_FAILURE_STRINGS +// to avoid compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// To query the width, height and component count of an image without having to +// decode the full file, you can use the stbi_info family of functions: +// +// int x,y,n,ok; +// ok = stbi_info(filename, &x, &y, &n); +// // returns ok=1 and sets x, y, n if image is a supported format, +// // 0 otherwise. +// +// Note that stb_image pervasively uses ints in its public API for sizes, +// including sizes of memory buffers. This is now part of the API and thus +// hard to change without causing breakage. As a result, the various image +// loaders all have certain limits on image size; these differ somewhat +// by format but generally boil down to either just under 2GB or just under +// 1GB. When the decoded image would be larger than this, stb_image decoding +// will fail. +// +// Additionally, stb_image will reject image files that have any of their +// dimensions set to a larger value than the configurable STBI_MAX_DIMENSIONS, +// which defaults to 2**24 = 16777216 pixels. Due to the above memory limit, +// the only way to have an image with such dimensions load correctly +// is for it to have a rather extreme aspect ratio. Either way, the +// assumption here is that such larger images are likely to be malformed +// or malicious. If you do need to load an image with individual dimensions +// larger than that, and it still fits in the overall size limit, you can +// #define STBI_MAX_DIMENSIONS on your own to be something larger. +// +// =========================================================================== +// +// UNICODE: +// +// If compiling for Windows and you wish to use Unicode filenames, compile +// with +// #define STBI_WINDOWS_UTF8 +// and pass utf8-encoded filenames. Call stbi_convert_wchar_to_utf8 to convert +// Windows wchar_t filenames to utf8. +// +// =========================================================================== +// +// Philosophy +// +// stb libraries are designed with the following priorities: +// +// 1. easy to use +// 2. easy to maintain +// 3. good performance +// +// Sometimes I let "good performance" creep up in priority over "easy to maintain", +// and for best performance I may provide less-easy-to-use APIs that give higher +// performance, in addition to the easy-to-use ones. Nevertheless, it's important +// to keep in mind that from the standpoint of you, a client of this library, +// all you care about is #1 and #3, and stb libraries DO NOT emphasize #3 above all. +// +// Some secondary priorities arise directly from the first two, some of which +// provide more explicit reasons why performance can't be emphasized. +// +// - Portable ("ease of use") +// - Small source code footprint ("easy to maintain") +// - No dependencies ("ease of use") +// +// =========================================================================== +// +// I/O callbacks +// +// I/O callbacks allow you to read from arbitrary sources, like packaged +// files or some other source. Data read from callbacks are processed +// through a small internal buffer (currently 128 bytes) to try to reduce +// overhead. +// +// The three functions you must define are "read" (reads some bytes of data), +// "skip" (skips some bytes of data), "eof" (reports if the stream is at the end). +// +// =========================================================================== +// +// SIMD support +// +// The JPEG decoder will try to automatically use SIMD kernels on x86 when +// supported by the compiler. For ARM Neon support, you must explicitly +// request it. +// +// (The old do-it-yourself SIMD API is no longer supported in the current +// code.) +// +// On x86, SSE2 will automatically be used when available based on a run-time +// test; if not, the generic C versions are used as a fall-back. On ARM targets, +// the typical path is to have separate builds for NEON and non-NEON devices +// (at least this is true for iOS and Android). Therefore, the NEON support is +// toggled by a build flag: define STBI_NEON to get NEON loops. +// +// If for some reason you do not want to use any of SIMD code, or if +// you have issues compiling it, you can disable it entirely by +// defining STBI_NO_SIMD. +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image supports loading HDR images in general, and currently the Radiance +// .HDR file format specifically. You can still load any file through the existing +// interface; if you attempt to load an HDR file, it will be automatically remapped +// to LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); +// +// =========================================================================== +// +// iPhone PNG support: +// +// We optionally support converting iPhone-formatted PNGs (which store +// premultiplied BGRA) back to RGB, even though they're internally encoded +// differently. To enable this conversion, call +// stbi_convert_iphone_png_to_rgb(1). +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// ADDITIONAL CONFIGURATION +// +// - You can suppress implementation of any of the decoders to reduce +// your code footprint by #defining one or more of the following +// symbols before creating the implementation. +// +// STBI_NO_JPEG +// STBI_NO_PNG +// STBI_NO_BMP +// STBI_NO_PSD +// STBI_NO_TGA +// STBI_NO_GIF +// STBI_NO_HDR +// STBI_NO_PIC +// STBI_NO_PNM (.ppm and .pgm) +// +// - You can request *only* certain decoders and suppress all other ones +// (this will be more forward-compatible, as addition of new decoders +// doesn't require you to disable them explicitly): +// +// STBI_ONLY_JPEG +// STBI_ONLY_PNG +// STBI_ONLY_BMP +// STBI_ONLY_PSD +// STBI_ONLY_TGA +// STBI_ONLY_GIF +// STBI_ONLY_HDR +// STBI_ONLY_PIC +// STBI_ONLY_PNM (.ppm and .pgm) +// +// - If you use STBI_NO_PNG (or _ONLY_ without PNG), and you still +// want the zlib decoder to be available, #define STBI_SUPPORT_ZLIB +// +// - If you define STBI_MAX_DIMENSIONS, stb_image will reject images greater +// than that size (in either width or height) without further processing. +// This is to let programs in the wild set an upper bound to prevent +// denial-of-service attacks on untrusted data, as one could generate a +// valid image of gigantic dimensions and force stb_image to allocate a +// huge block of memory and spend disproportionate time decoding it. By +// default this is set to (1 << 24), which is 16777216, but that's still +// very big. + +#ifndef STBI_NO_STDIO +#include +#endif // STBI_NO_STDIO + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for desired_channels + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4 +}; + +#include +typedef unsigned char stbi_uc; +typedef unsigned short stbi_us; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef STBIDEF +#ifdef STB_IMAGE_STATIC +#define STBIDEF static +#else +#define STBIDEF extern +#endif +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// PRIMARY API - works on images of any type +// + +// +// load image by filename, open file, or memory buffer +// + +typedef struct +{ + int (*read) (void *user,char *data,int size); // fill 'data' with 'size' bytes. return number of bytes actually read + void (*skip) (void *user,int n); // skip the next 'n' bytes, or 'unget' the last -n bytes if negative + int (*eof) (void *user); // returns nonzero if we are at end of file/data +} stbi_io_callbacks; + +//////////////////////////////////// +// +// 8-bits-per-channel interface +// + +STBIDEF stbi_uc *stbi_load_from_memory (stbi_uc const *buffer, int len , int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk , void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_uc *stbi_load (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +#endif + +#ifdef STBI_WINDOWS_UTF8 +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); +#endif + +//////////////////////////////////// +// +// 16-bits-per-channel interface +// + +STBIDEF stbi_us *stbi_load_16_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + +#ifndef STBI_NO_STDIO +STBIDEF stbi_us *stbi_load_16 (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); +STBIDEF stbi_us *stbi_load_from_file_16(FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); +#endif + +//////////////////////////////////// +// +// float-per-channel interface +// +#ifndef STBI_NO_LINEAR + STBIDEF float *stbi_loadf_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_callbacks (stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels); + + #ifndef STBI_NO_STDIO + STBIDEF float *stbi_loadf (char const *filename, int *x, int *y, int *channels_in_file, int desired_channels); + STBIDEF float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *channels_in_file, int desired_channels); + #endif +#endif + +#ifndef STBI_NO_HDR + STBIDEF void stbi_hdr_to_ldr_gamma(float gamma); + STBIDEF void stbi_hdr_to_ldr_scale(float scale); +#endif // STBI_NO_HDR + +#ifndef STBI_NO_LINEAR + STBIDEF void stbi_ldr_to_hdr_gamma(float gamma); + STBIDEF void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_LINEAR + +// stbi_is_hdr is always defined, but always returns false if STBI_NO_HDR +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user); +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename); +STBIDEF int stbi_is_hdr_from_file(FILE *f); +#endif // STBI_NO_STDIO + + +// get a VERY brief reason for failure +// on most compilers (and ALL modern mainstream compilers) this is threadsafe +STBIDEF const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +STBIDEF void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len); +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *clbk, void *user); + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info (char const *filename, int *x, int *y, int *comp); +STBIDEF int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); +STBIDEF int stbi_is_16_bit (char const *filename); +STBIDEF int stbi_is_16_bit_from_file(FILE *f); +#endif + + + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + +// flip the image vertically, so the first pixel in the output array is the bottom left +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip); + +// as above, but only applies to images loaded on the thread that calls the function +// this function is only available if your compiler supports thread-local variables; +// calling it will fail to link if your compiler doesn't +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply); +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert); +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip); + +// ZLIB client - used by PNG, available for other purposes + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header); +STBIDEF char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +STBIDEF char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifdef STB_IMAGE_IMPLEMENTATION + +#if defined(STBI_ONLY_JPEG) || defined(STBI_ONLY_PNG) || defined(STBI_ONLY_BMP) \ + || defined(STBI_ONLY_TGA) || defined(STBI_ONLY_GIF) || defined(STBI_ONLY_PSD) \ + || defined(STBI_ONLY_HDR) || defined(STBI_ONLY_PIC) || defined(STBI_ONLY_PNM) \ + || defined(STBI_ONLY_ZLIB) + #ifndef STBI_ONLY_JPEG + #define STBI_NO_JPEG + #endif + #ifndef STBI_ONLY_PNG + #define STBI_NO_PNG + #endif + #ifndef STBI_ONLY_BMP + #define STBI_NO_BMP + #endif + #ifndef STBI_ONLY_PSD + #define STBI_NO_PSD + #endif + #ifndef STBI_ONLY_TGA + #define STBI_NO_TGA + #endif + #ifndef STBI_ONLY_GIF + #define STBI_NO_GIF + #endif + #ifndef STBI_ONLY_HDR + #define STBI_NO_HDR + #endif + #ifndef STBI_ONLY_PIC + #define STBI_NO_PIC + #endif + #ifndef STBI_ONLY_PNM + #define STBI_NO_PNM + #endif +#endif + +#if defined(STBI_NO_PNG) && !defined(STBI_SUPPORT_ZLIB) && !defined(STBI_NO_ZLIB) +#define STBI_NO_ZLIB +#endif + + +#include +#include // ptrdiff_t on osx +#include +#include +#include + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) +#include // ldexp, pow +#endif + +#ifndef STBI_NO_STDIO +#include +#endif + +#ifndef STBI_ASSERT +#include +#define STBI_ASSERT(x) assert(x) +#endif + +#ifdef __cplusplus +#define STBI_EXTERN extern "C" +#else +#define STBI_EXTERN extern +#endif + + +#ifndef _MSC_VER + #ifdef __cplusplus + #define stbi_inline inline + #else + #define stbi_inline + #endif +#else + #define stbi_inline __forceinline +#endif + +#ifndef STBI_NO_THREAD_LOCALS + #if defined(__cplusplus) && __cplusplus >= 201103L + #define STBI_THREAD_LOCAL thread_local + #elif defined(__GNUC__) && __GNUC__ < 5 + #define STBI_THREAD_LOCAL __thread + #elif defined(_MSC_VER) + #define STBI_THREAD_LOCAL __declspec(thread) + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L && !defined(__STDC_NO_THREADS__) + #define STBI_THREAD_LOCAL _Thread_local + #endif + + #ifndef STBI_THREAD_LOCAL + #if defined(__GNUC__) + #define STBI_THREAD_LOCAL __thread + #endif + #endif +#endif + +#if defined(_MSC_VER) || defined(__SYMBIAN32__) +typedef unsigned short stbi__uint16; +typedef signed short stbi__int16; +typedef unsigned int stbi__uint32; +typedef signed int stbi__int32; +#else +#include +typedef uint16_t stbi__uint16; +typedef int16_t stbi__int16; +typedef uint32_t stbi__uint32; +typedef int32_t stbi__int32; +#endif + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(stbi__uint32)==4 ? 1 : -1]; + +#ifdef _MSC_VER +#define STBI_NOTUSED(v) (void)(v) +#else +#define STBI_NOTUSED(v) (void)sizeof(v) +#endif + +#ifdef _MSC_VER +#define STBI_HAS_LROTL +#endif + +#ifdef STBI_HAS_LROTL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (-(y) & 31))) +#endif + +#if defined(STBI_MALLOC) && defined(STBI_FREE) && (defined(STBI_REALLOC) || defined(STBI_REALLOC_SIZED)) +// ok +#elif !defined(STBI_MALLOC) && !defined(STBI_FREE) && !defined(STBI_REALLOC) && !defined(STBI_REALLOC_SIZED) +// ok +#else +#error "Must define all or none of STBI_MALLOC, STBI_FREE, and STBI_REALLOC (or STBI_REALLOC_SIZED)." +#endif + +#ifndef STBI_MALLOC +#define STBI_MALLOC(sz) malloc(sz) +#define STBI_REALLOC(p,newsz) realloc(p,newsz) +#define STBI_FREE(p) free(p) +#endif + +#ifndef STBI_REALLOC_SIZED +#define STBI_REALLOC_SIZED(p,oldsz,newsz) STBI_REALLOC(p,newsz) +#endif + +// x86/x64 detection +#if defined(__x86_64__) || defined(_M_X64) +#define STBI__X64_TARGET +#elif defined(__i386) || defined(_M_IX86) +#define STBI__X86_TARGET +#endif + +#if defined(__GNUC__) && defined(STBI__X86_TARGET) && !defined(__SSE2__) && !defined(STBI_NO_SIMD) +// gcc doesn't support sse2 intrinsics unless you compile with -msse2, +// which in turn means it gets to use SSE2 everywhere. This is unfortunate, +// but previous attempts to provide the SSE2 functions with runtime +// detection caused numerous issues. The way architecture extensions are +// exposed in GCC/Clang is, sadly, not really suited for one-file libs. +// New behavior: if compiled with -msse2, we use SSE2 without any +// detection; if not, we don't use it at all. +#define STBI_NO_SIMD +#endif + +#if defined(__MINGW32__) && defined(STBI__X86_TARGET) && !defined(STBI_MINGW_ENABLE_SSE2) && !defined(STBI_NO_SIMD) +// Note that __MINGW32__ doesn't actually mean 32-bit, so we have to avoid STBI__X64_TARGET +// +// 32-bit MinGW wants ESP to be 16-byte aligned, but this is not in the +// Windows ABI and VC++ as well as Windows DLLs don't maintain that invariant. +// As a result, enabling SSE2 on 32-bit MinGW is dangerous when not +// simultaneously enabling "-mstackrealign". +// +// See https://github.com/nothings/stb/issues/81 for more information. +// +// So default to no SSE2 on 32-bit MinGW. If you've read this far and added +// -mstackrealign to your build settings, feel free to #define STBI_MINGW_ENABLE_SSE2. +#define STBI_NO_SIMD +#endif + +#if !defined(STBI_NO_SIMD) && (defined(STBI__X86_TARGET) || defined(STBI__X64_TARGET)) +#define STBI_SSE2 +#include + +#ifdef _MSC_VER + +#if _MSC_VER >= 1400 // not VC6 +#include // __cpuid +static int stbi__cpuid3(void) +{ + int info[4]; + __cpuid(info,1); + return info[3]; +} +#else +static int stbi__cpuid3(void) +{ + int res; + __asm { + mov eax,1 + cpuid + mov res,edx + } + return res; +} +#endif + +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + int info3 = stbi__cpuid3(); + return ((info3 >> 26) & 1) != 0; +} +#endif + +#else // assume GCC-style if not VC++ +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) + +#if !defined(STBI_NO_JPEG) && defined(STBI_SSE2) +static int stbi__sse2_available(void) +{ + // If we're even attempting to compile this on GCC/Clang, that means + // -msse2 is on, which means the compiler is allowed to use SSE2 + // instructions at will, and so are we. + return 1; +} +#endif + +#endif +#endif + +// ARM NEON +#if defined(STBI_NO_SIMD) && defined(STBI_NEON) +#undef STBI_NEON +#endif + +#ifdef STBI_NEON +#include +#ifdef _MSC_VER +#define STBI_SIMD_ALIGN(type, name) __declspec(align(16)) type name +#else +#define STBI_SIMD_ALIGN(type, name) type name __attribute__((aligned(16))) +#endif +#endif + +#ifndef STBI_SIMD_ALIGN +#define STBI_SIMD_ALIGN(type, name) type name +#endif + +#ifndef STBI_MAX_DIMENSIONS +#define STBI_MAX_DIMENSIONS (1 << 24) +#endif + +/////////////////////////////////////////////// +// +// stbi__context struct and start_xxx functions + +// stbi__context structure is our basic context used by all images, so it +// contains all the IO context, plus some basic image information +typedef struct +{ + stbi__uint32 img_x, img_y; + int img_n, img_out_n; + + stbi_io_callbacks io; + void *io_user_data; + + int read_from_callbacks; + int buflen; + stbi_uc buffer_start[128]; + int callback_already_read; + + stbi_uc *img_buffer, *img_buffer_end; + stbi_uc *img_buffer_original, *img_buffer_original_end; +} stbi__context; + + +static void stbi__refill_buffer(stbi__context *s); + +// initialize a memory-decode context +static void stbi__start_mem(stbi__context *s, stbi_uc const *buffer, int len) +{ + s->io.read = NULL; + s->read_from_callbacks = 0; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = (stbi_uc *) buffer; + s->img_buffer_end = s->img_buffer_original_end = (stbi_uc *) buffer+len; +} + +// initialize a callback-based context +static void stbi__start_callbacks(stbi__context *s, stbi_io_callbacks *c, void *user) +{ + s->io = *c; + s->io_user_data = user; + s->buflen = sizeof(s->buffer_start); + s->read_from_callbacks = 1; + s->callback_already_read = 0; + s->img_buffer = s->img_buffer_original = s->buffer_start; + stbi__refill_buffer(s); + s->img_buffer_original_end = s->img_buffer_end; +} + +#ifndef STBI_NO_STDIO + +static int stbi__stdio_read(void *user, char *data, int size) +{ + return (int) fread(data,1,size,(FILE*) user); +} + +static void stbi__stdio_skip(void *user, int n) +{ + int ch; + fseek((FILE*) user, n, SEEK_CUR); + ch = fgetc((FILE*) user); /* have to read a byte to reset feof()'s flag */ + if (ch != EOF) { + ungetc(ch, (FILE *) user); /* push byte back onto stream if valid. */ + } +} + +static int stbi__stdio_eof(void *user) +{ + return feof((FILE*) user) || ferror((FILE *) user); +} + +static stbi_io_callbacks stbi__stdio_callbacks = +{ + stbi__stdio_read, + stbi__stdio_skip, + stbi__stdio_eof, +}; + +static void stbi__start_file(stbi__context *s, FILE *f) +{ + stbi__start_callbacks(s, &stbi__stdio_callbacks, (void *) f); +} + +//static void stop_file(stbi__context *s) { } + +#endif // !STBI_NO_STDIO + +static void stbi__rewind(stbi__context *s) +{ + // conceptually rewind SHOULD rewind to the beginning of the stream, + // but we just rewind to the beginning of the initial buffer, because + // we only use it after doing 'test', which only ever looks at at most 92 bytes + s->img_buffer = s->img_buffer_original; + s->img_buffer_end = s->img_buffer_original_end; +} + +enum +{ + STBI_ORDER_RGB, + STBI_ORDER_BGR +}; + +typedef struct +{ + int bits_per_channel; + int num_channels; + int channel_order; +} stbi__result_info; + +#ifndef STBI_NO_JPEG +static int stbi__jpeg_test(stbi__context *s); +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNG +static int stbi__png_test(stbi__context *s); +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__png_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_BMP +static int stbi__bmp_test(stbi__context *s); +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_TGA +static int stbi__tga_test(stbi__context *s); +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s); +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc); +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__psd_is16(stbi__context *s); +#endif + +#ifndef STBI_NO_HDR +static int stbi__hdr_test(stbi__context *s); +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_test(stbi__context *s); +static void *stbi__pic_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_GIF +static int stbi__gif_test(stbi__context *s); +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp); +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp); +#endif + +#ifndef STBI_NO_PNM +static int stbi__pnm_test(stbi__context *s); +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri); +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp); +static int stbi__pnm_is16(stbi__context *s); +#endif + +static +#ifdef STBI_THREAD_LOCAL +STBI_THREAD_LOCAL +#endif +const char *stbi__g_failure_reason; + +STBIDEF const char *stbi_failure_reason(void) +{ + return stbi__g_failure_reason; +} + +#ifndef STBI_NO_FAILURE_STRINGS +static int stbi__err(const char *str) +{ + stbi__g_failure_reason = str; + return 0; +} +#endif + +static void *stbi__malloc(size_t size) +{ + return STBI_MALLOC(size); +} + +// stb_image uses ints pervasively, including for offset calculations. +// therefore the largest decoded image size we can support with the +// current code, even on 64-bit targets, is INT_MAX. this is not a +// significant limitation for the intended use case. +// +// we do, however, need to make sure our size calculations don't +// overflow. hence a few helper functions for size calculations that +// multiply integers together, making sure that they're non-negative +// and no overflow occurs. + +// return 1 if the sum is valid, 0 on overflow. +// negative terms are considered invalid. +static int stbi__addsizes_valid(int a, int b) +{ + if (b < 0) return 0; + // now 0 <= b <= INT_MAX, hence also + // 0 <= INT_MAX - b <= INTMAX. + // And "a + b <= INT_MAX" (which might overflow) is the + // same as a <= INT_MAX - b (no overflow) + return a <= INT_MAX - b; +} + +// returns 1 if the product is valid, 0 on overflow. +// negative factors are considered invalid. +static int stbi__mul2sizes_valid(int a, int b) +{ + if (a < 0 || b < 0) return 0; + if (b == 0) return 1; // mul-by-0 is always safe + // portable way to check for no overflows in a*b + return a <= INT_MAX/b; +} + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// returns 1 if "a*b + add" has no negative terms/factors and doesn't overflow +static int stbi__mad2sizes_valid(int a, int b, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__addsizes_valid(a*b, add); +} +#endif + +// returns 1 if "a*b*c + add" has no negative terms/factors and doesn't overflow +static int stbi__mad3sizes_valid(int a, int b, int c, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__addsizes_valid(a*b*c, add); +} + +// returns 1 if "a*b*c*d + add" has no negative terms/factors and doesn't overflow +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static int stbi__mad4sizes_valid(int a, int b, int c, int d, int add) +{ + return stbi__mul2sizes_valid(a, b) && stbi__mul2sizes_valid(a*b, c) && + stbi__mul2sizes_valid(a*b*c, d) && stbi__addsizes_valid(a*b*c*d, add); +} +#endif + +#if !defined(STBI_NO_JPEG) || !defined(STBI_NO_PNG) || !defined(STBI_NO_TGA) || !defined(STBI_NO_HDR) +// mallocs with size overflow checking +static void *stbi__malloc_mad2(int a, int b, int add) +{ + if (!stbi__mad2sizes_valid(a, b, add)) return NULL; + return stbi__malloc(a*b + add); +} +#endif + +static void *stbi__malloc_mad3(int a, int b, int c, int add) +{ + if (!stbi__mad3sizes_valid(a, b, c, add)) return NULL; + return stbi__malloc(a*b*c + add); +} + +#if !defined(STBI_NO_LINEAR) || !defined(STBI_NO_HDR) || !defined(STBI_NO_PNM) +static void *stbi__malloc_mad4(int a, int b, int c, int d, int add) +{ + if (!stbi__mad4sizes_valid(a, b, c, d, add)) return NULL; + return stbi__malloc(a*b*c*d + add); +} +#endif + +// returns 1 if the sum of two signed ints is valid (between -2^31 and 2^31-1 inclusive), 0 on overflow. +static int stbi__addints_valid(int a, int b) +{ + if ((a >= 0) != (b >= 0)) return 1; // a and b have different signs, so no overflow + if (a < 0 && b < 0) return a >= INT_MIN - b; // same as a + b >= INT_MIN; INT_MIN - b cannot overflow since b < 0. + return a <= INT_MAX - b; +} + +// returns 1 if the product of two ints fits in a signed short, 0 on overflow. +static int stbi__mul2shorts_valid(int a, int b) +{ + if (b == 0 || b == -1) return 1; // multiplication by 0 is always 0; check for -1 so SHRT_MIN/b doesn't overflow + if ((a >= 0) == (b >= 0)) return a <= SHRT_MAX/b; // product is positive, so similar to mul2sizes_valid + if (b < 0) return a <= SHRT_MIN / b; // same as a * b >= SHRT_MIN + return a >= SHRT_MIN / b; +} + +// stbi__err - error +// stbi__errpf - error returning pointer to float +// stbi__errpuc - error returning pointer to unsigned char + +#ifdef STBI_NO_FAILURE_STRINGS + #define stbi__err(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define stbi__err(x,y) stbi__err(y) +#else + #define stbi__err(x,y) stbi__err(x) +#endif + +#define stbi__errpf(x,y) ((float *)(size_t) (stbi__err(x,y)?NULL:NULL)) +#define stbi__errpuc(x,y) ((unsigned char *)(size_t) (stbi__err(x,y)?NULL:NULL)) + +STBIDEF void stbi_image_free(void *retval_from_stbi_load) +{ + STBI_FREE(retval_from_stbi_load); +} + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_HDR +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +static int stbi__vertically_flip_on_load_global = 0; + +STBIDEF void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_global = flag_true_if_should_flip; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__vertically_flip_on_load stbi__vertically_flip_on_load_global +#else +static STBI_THREAD_LOCAL int stbi__vertically_flip_on_load_local, stbi__vertically_flip_on_load_set; + +STBIDEF void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip) +{ + stbi__vertically_flip_on_load_local = flag_true_if_should_flip; + stbi__vertically_flip_on_load_set = 1; +} + +#define stbi__vertically_flip_on_load (stbi__vertically_flip_on_load_set \ + ? stbi__vertically_flip_on_load_local \ + : stbi__vertically_flip_on_load_global) +#endif // STBI_THREAD_LOCAL + +static void *stbi__load_main(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + memset(ri, 0, sizeof(*ri)); // make sure it's initialized if we add new fields + ri->bits_per_channel = 8; // default is 8 so most paths don't have to be changed + ri->channel_order = STBI_ORDER_RGB; // all current input & output are this, but this is here so we can add BGR order + ri->num_channels = 0; + + // test the formats with a very explicit header first (at least a FOURCC + // or distinctive magic number first) + #ifndef STBI_NO_PNG + if (stbi__png_test(s)) return stbi__png_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_BMP + if (stbi__bmp_test(s)) return stbi__bmp_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_GIF + if (stbi__gif_test(s)) return stbi__gif_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PSD + if (stbi__psd_test(s)) return stbi__psd_load(s,x,y,comp,req_comp, ri, bpc); + #else + STBI_NOTUSED(bpc); + #endif + #ifndef STBI_NO_PIC + if (stbi__pic_test(s)) return stbi__pic_load(s,x,y,comp,req_comp, ri); + #endif + + // then the formats that can end up attempting to load with just 1 or 2 + // bytes matching expectations; these are prone to false positives, so + // try them later + #ifndef STBI_NO_JPEG + if (stbi__jpeg_test(s)) return stbi__jpeg_load(s,x,y,comp,req_comp, ri); + #endif + #ifndef STBI_NO_PNM + if (stbi__pnm_test(s)) return stbi__pnm_load(s,x,y,comp,req_comp, ri); + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + float *hdr = stbi__hdr_load(s, x,y,comp,req_comp, ri); + return stbi__hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + #ifndef STBI_NO_TGA + // test tga last because it's a crappy test! + if (stbi__tga_test(s)) + return stbi__tga_load(s,x,y,comp,req_comp, ri); + #endif + + return stbi__errpuc("unknown image type", "Image not of any known type, or corrupt"); +} + +static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi_uc *reduced; + + reduced = (stbi_uc *) stbi__malloc(img_len); + if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + reduced[i] = (stbi_uc)((orig[i] >> 8) & 0xFF); // top half of each byte is sufficient approx of 16->8 bit scaling + + STBI_FREE(orig); + return reduced; +} + +static stbi__uint16 *stbi__convert_8_to_16(stbi_uc *orig, int w, int h, int channels) +{ + int i; + int img_len = w * h * channels; + stbi__uint16 *enlarged; + + enlarged = (stbi__uint16 *) stbi__malloc(img_len*2); + if (enlarged == NULL) return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + + for (i = 0; i < img_len; ++i) + enlarged[i] = (stbi__uint16)((orig[i] << 8) + orig[i]); // replicate to high and low byte, maps 0->0, 255->0xffff + + STBI_FREE(orig); + return enlarged; +} + +static void stbi__vertical_flip(void *image, int w, int h, int bytes_per_pixel) +{ + int row; + size_t bytes_per_row = (size_t)w * bytes_per_pixel; + stbi_uc temp[2048]; + stbi_uc *bytes = (stbi_uc *)image; + + for (row = 0; row < (h>>1); row++) { + stbi_uc *row0 = bytes + row*bytes_per_row; + stbi_uc *row1 = bytes + (h - row - 1)*bytes_per_row; + // swap row0 with row1 + size_t bytes_left = bytes_per_row; + while (bytes_left) { + size_t bytes_copy = (bytes_left < sizeof(temp)) ? bytes_left : sizeof(temp); + memcpy(temp, row0, bytes_copy); + memcpy(row0, row1, bytes_copy); + memcpy(row1, temp, bytes_copy); + row0 += bytes_copy; + row1 += bytes_copy; + bytes_left -= bytes_copy; + } + } +} + +#ifndef STBI_NO_GIF +static void stbi__vertical_flip_slices(void *image, int w, int h, int z, int bytes_per_pixel) +{ + int slice; + int slice_size = w * h * bytes_per_pixel; + + stbi_uc *bytes = (stbi_uc *)image; + for (slice = 0; slice < z; ++slice) { + stbi__vertical_flip(bytes, w, h, bytes_per_pixel); + bytes += slice_size; + } +} +#endif + +static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 8) { + result = stbi__convert_16_to_8((stbi__uint16 *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 8; + } + + // @TODO: move stbi__convert_format to here + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi_uc)); + } + + return (unsigned char *) result; +} + +static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + stbi__result_info ri; + void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16); + + if (result == NULL) + return NULL; + + // it is the responsibility of the loaders to make sure we get either 8 or 16 bit. + STBI_ASSERT(ri.bits_per_channel == 8 || ri.bits_per_channel == 16); + + if (ri.bits_per_channel != 16) { + result = stbi__convert_8_to_16((stbi_uc *) result, *x, *y, req_comp == 0 ? *comp : req_comp); + ri.bits_per_channel = 16; + } + + // @TODO: move stbi__convert_format16 to here + // @TODO: special case RGB-to-Y (and RGBA-to-YA) for 8-bit-to-16-bit case to keep more precision + + if (stbi__vertically_flip_on_load) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(stbi__uint16)); + } + + return (stbi__uint16 *) result; +} + +#if !defined(STBI_NO_HDR) && !defined(STBI_NO_LINEAR) +static void stbi__float_postprocess(float *result, int *x, int *y, int *comp, int req_comp) +{ + if (stbi__vertically_flip_on_load && result != NULL) { + int channels = req_comp ? req_comp : *comp; + stbi__vertical_flip(result, *x, *y, channels * sizeof(float)); + } +} +#endif + +#ifndef STBI_NO_STDIO + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBI_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); +STBI_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); +#endif + +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) +STBIDEF int stbi_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) +{ + return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); +} +#endif + +static FILE *stbi__fopen(char const *filename, char const *mode) +{ + FILE *f; +#if defined(_WIN32) && defined(STBI_WINDOWS_UTF8) + wchar_t wMode[64]; + wchar_t wFilename[1024]; + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) + return 0; + + if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) + return 0; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != _wfopen_s(&f, wFilename, wMode)) + f = 0; +#else + f = _wfopen(wFilename, wMode); +#endif + +#elif defined(_MSC_VER) && _MSC_VER >= 1400 + if (0 != fopen_s(&f, filename, mode)) + f=0; +#else + f = fopen(filename, mode); +#endif + return f; +} + + +STBIDEF stbi_uc *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + unsigned char *result; + if (!f) return stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__uint16 *result; + stbi__context s; + stbi__start_file(&s,f); + result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp); + if (result) { + // need to 'unget' all the characters in the IO buffer + fseek(f, - (int) (s.img_buffer_end - s.img_buffer), SEEK_CUR); + } + return result; +} + +STBIDEF stbi_us *stbi_load_16(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + stbi__uint16 *result; + if (!f) return (stbi_us *) stbi__errpuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file_16(f,x,y,comp,req_comp); + fclose(f); + return result; +} + + +#endif //!STBI_NO_STDIO + +STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user); + return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels); +} + +STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_GIF +STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + unsigned char *result; + stbi__context s; + stbi__start_mem(&s,buffer,len); + + result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp); + if (stbi__vertically_flip_on_load) { + stbi__vertical_flip_slices( result, *x, *y, *z, *comp ); + } + + return result; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi__hdr_test(s)) { + stbi__result_info ri; + float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri); + if (hdr_data) + stbi__float_postprocess(hdr_data,x,y,comp,req_comp); + return hdr_data; + } + #endif + data = stbi__load_and_postprocess_8bit(s, x, y, comp, req_comp); + if (data) + return stbi__ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return stbi__errpf("unknown image type", "Image not of any known type, or corrupt"); +} + +STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + float *result; + FILE *f = stbi__fopen(filename, "rb"); + if (!f) return stbi__errpf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi__context s; + stbi__start_file(&s,f); + return stbi__loadf_main(&s,x,y,comp,req_comp); +} +#endif // !STBI_NO_STDIO + +#endif // !STBI_NO_LINEAR + +// these is-hdr-or-not is defined independent of whether STBI_NO_LINEAR is +// defined, for API simplicity; if STBI_NO_LINEAR is defined, it always +// reports false! + +STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(buffer); + STBI_NOTUSED(len); + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_is_hdr (char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +STBIDEF int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + long pos = ftell(f); + int res; + stbi__context s; + stbi__start_file(&s,f); + res = stbi__hdr_test(&s); + fseek(f, pos, SEEK_SET); + return res; + #else + STBI_NOTUSED(f); + return 0; + #endif +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_is_hdr_from_callbacks(stbi_io_callbacks const *clbk, void *user) +{ + #ifndef STBI_NO_HDR + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user); + return stbi__hdr_test(&s); + #else + STBI_NOTUSED(clbk); + STBI_NOTUSED(user); + return 0; + #endif +} + +#ifndef STBI_NO_LINEAR +static float stbi__l2h_gamma=2.2f, stbi__l2h_scale=1.0f; + +STBIDEF void stbi_ldr_to_hdr_gamma(float gamma) { stbi__l2h_gamma = gamma; } +STBIDEF void stbi_ldr_to_hdr_scale(float scale) { stbi__l2h_scale = scale; } +#endif + +static float stbi__h2l_gamma_i=1.0f/2.2f, stbi__h2l_scale_i=1.0f; + +STBIDEF void stbi_hdr_to_ldr_gamma(float gamma) { stbi__h2l_gamma_i = 1/gamma; } +STBIDEF void stbi_hdr_to_ldr_scale(float scale) { stbi__h2l_scale_i = 1/scale; } + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + STBI__SCAN_load=0, + STBI__SCAN_type, + STBI__SCAN_header +}; + +static void stbi__refill_buffer(stbi__context *s) +{ + int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen); + s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original); + if (n == 0) { + // at end of file, treat same as if from memory, but need to handle case + // where s->img_buffer isn't pointing to safe memory, e.g. 0-byte file + s->read_from_callbacks = 0; + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start+1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} + +stbi_inline static stbi_uc stbi__get8(stbi__context *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; + if (s->read_from_callbacks) { + stbi__refill_buffer(s); + return *s->img_buffer++; + } + return 0; +} + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_HDR) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +stbi_inline static int stbi__at_eof(stbi__context *s) +{ + if (s->io.read) { + if (!(s->io.eof)(s->io_user_data)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->read_from_callbacks == 0) return 1; + } + + return s->img_buffer >= s->img_buffer_end; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) +// nothing +#else +static void stbi__skip(stbi__context *s, int n) +{ + if (n == 0) return; // already there! + if (n < 0) { + s->img_buffer = s->img_buffer_end; + return; + } + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + s->img_buffer = s->img_buffer_end; + (s->io.skip)(s->io_user_data, n - blen); + return; + } + } + s->img_buffer += n; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_TGA) && defined(STBI_NO_HDR) && defined(STBI_NO_PNM) +// nothing +#else +static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n) +{ + if (s->io.read) { + int blen = (int) (s->img_buffer_end - s->img_buffer); + if (blen < n) { + int res, count; + + memcpy(buffer, s->img_buffer, blen); + + count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen); + res = (count == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } + + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} +#endif + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static int stbi__get16be(stbi__context *s) +{ + int z = stbi__get8(s); + return (z << 8) + stbi__get8(s); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) && defined(STBI_NO_PIC) +// nothing +#else +static stbi__uint32 stbi__get32be(stbi__context *s) +{ + stbi__uint32 z = stbi__get16be(s); + return (z << 16) + stbi__get16be(s); +} +#endif + +#if defined(STBI_NO_BMP) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) +// nothing +#else +static int stbi__get16le(stbi__context *s) +{ + int z = stbi__get8(s); + return z + (stbi__get8(s) << 8); +} +#endif + +#ifndef STBI_NO_BMP +static stbi__uint32 stbi__get32le(stbi__context *s) +{ + stbi__uint32 z = stbi__get16le(s); + z += (stbi__uint32)stbi__get16le(s) << 16; + return z; +} +#endif + +#define STBI__BYTECAST(x) ((stbi_uc) ((x) & 255)) // truncate int to byte without warnings + +#if defined(STBI_NO_JPEG) && defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static stbi_uc stbi__compute_y(int r, int g, int b) +{ + return (stbi_uc) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_BMP) && defined(STBI_NO_PSD) && defined(STBI_NO_TGA) && defined(STBI_NO_GIF) && defined(STBI_NO_PIC) && defined(STBI_NO_PNM) +// nothing +#else +static unsigned char *stbi__convert_format(unsigned char *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) stbi__malloc_mad3(req_comp, x, y, 0); + if (good == NULL) { + STBI_FREE(data); + return stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=255; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=255; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=255; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = 255; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 stbi__compute_y_16(int r, int g, int b) +{ + return (stbi__uint16) (((r*77) + (g*150) + (29*b)) >> 8); +} +#endif + +#if defined(STBI_NO_PNG) && defined(STBI_NO_PSD) +// nothing +#else +static stbi__uint16 *stbi__convert_format16(stbi__uint16 *data, int img_n, int req_comp, unsigned int x, unsigned int y) +{ + int i,j; + stbi__uint16 *good; + + if (req_comp == img_n) return data; + STBI_ASSERT(req_comp >= 1 && req_comp <= 4); + + good = (stbi__uint16 *) stbi__malloc(req_comp * x * y * 2); + if (good == NULL) { + STBI_FREE(data); + return (stbi__uint16 *) stbi__errpuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + stbi__uint16 *src = data + j * x * img_n ; + stbi__uint16 *dest = good + j * x * req_comp; + + #define STBI__COMBO(a,b) ((a)*8+(b)) + #define STBI__CASE(a,b) case STBI__COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (STBI__COMBO(img_n, req_comp)) { + STBI__CASE(1,2) { dest[0]=src[0]; dest[1]=0xffff; } break; + STBI__CASE(1,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(1,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=0xffff; } break; + STBI__CASE(2,1) { dest[0]=src[0]; } break; + STBI__CASE(2,3) { dest[0]=dest[1]=dest[2]=src[0]; } break; + STBI__CASE(2,4) { dest[0]=dest[1]=dest[2]=src[0]; dest[3]=src[1]; } break; + STBI__CASE(3,4) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2];dest[3]=0xffff; } break; + STBI__CASE(3,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(3,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = 0xffff; } break; + STBI__CASE(4,1) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); } break; + STBI__CASE(4,2) { dest[0]=stbi__compute_y_16(src[0],src[1],src[2]); dest[1] = src[3]; } break; + STBI__CASE(4,3) { dest[0]=src[0];dest[1]=src[1];dest[2]=src[2]; } break; + default: STBI_ASSERT(0); STBI_FREE(data); STBI_FREE(good); return (stbi__uint16*) stbi__errpuc("unsupported", "Unsupported format conversion"); + } + #undef STBI__CASE + } + + STBI_FREE(data); + return good; +} +#endif + +#ifndef STBI_NO_LINEAR +static float *stbi__ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output; + if (!data) return NULL; + output = (float *) stbi__malloc_mad4(x, y, comp, sizeof(float), 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) (pow(data[i*comp+k]/255.0f, stbi__l2h_gamma) * stbi__l2h_scale); + } + } + if (n < comp) { + for (i=0; i < x*y; ++i) { + output[i*comp + n] = data[i*comp + n]/255.0f; + } + } + STBI_FREE(data); + return output; +} +#endif + +#ifndef STBI_NO_HDR +#define stbi__float2int(x) ((int) (x)) +static stbi_uc *stbi__hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output; + if (!data) return NULL; + output = (stbi_uc *) stbi__malloc_mad3(x, y, comp, 0); + if (output == NULL) { STBI_FREE(data); return stbi__errpuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*stbi__h2l_scale_i, stbi__h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (stbi_uc) stbi__float2int(z); + } + } + STBI_FREE(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder +// +// simple implementation +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - some SIMD kernels for common paths on targets with SSE2/NEON +// - uses a lot of intermediate memory, could cache poorly + +#ifndef STBI_NO_JPEG + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + stbi_uc fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + stbi__uint16 code[256]; + stbi_uc values[256]; + stbi_uc size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} stbi__huffman; + +typedef struct +{ + stbi__context *s; + stbi__huffman huff_dc[4]; + stbi__huffman huff_ac[4]; + stbi__uint16 dequant[4][64]; + stbi__int16 fast_ac[4][1 << FAST_BITS]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + stbi_uc *data; + void *raw_data, *raw_coeff; + stbi_uc *linebuf; + short *coeff; // progressive only + int coeff_w, coeff_h; // number of 8x8 coefficient blocks + } img_comp[4]; + + stbi__uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int progressive; + int spec_start; + int spec_end; + int succ_high; + int succ_low; + int eob_run; + int jfif; + int app14_color_transform; // Adobe APP14 tag + int rgb; + + int scan_n, order[4]; + int restart_interval, todo; + +// kernels + void (*idct_block_kernel)(stbi_uc *out, int out_stride, short data[64]); + void (*YCbCr_to_RGB_kernel)(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step); + stbi_uc *(*resample_row_hv_2_kernel)(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs); +} stbi__jpeg; + +static int stbi__build_huffman(stbi__huffman *h, int *count) +{ + int i,j,k=0; + unsigned int code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) { + for (j=0; j < count[i]; ++j) { + h->size[k++] = (stbi_uc) (i+1); + if(k >= 257) return stbi__err("bad size list","Corrupt JPEG"); + } + } + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (stbi__uint16) (code++); + if (code-1 >= (1u << j)) return stbi__err("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (stbi_uc) i; + } + } + } + return 1; +} + +// build a table that decodes both magnitude and value of small ACs in +// one go. +static void stbi__build_fast_ac(stbi__int16 *fast_ac, stbi__huffman *h) +{ + int i; + for (i=0; i < (1 << FAST_BITS); ++i) { + stbi_uc fast = h->fast[i]; + fast_ac[i] = 0; + if (fast < 255) { + int rs = h->values[fast]; + int run = (rs >> 4) & 15; + int magbits = rs & 15; + int len = h->size[fast]; + + if (magbits && len + magbits <= FAST_BITS) { + // magnitude code followed by receive_extend code + int k = ((i << len) & ((1 << FAST_BITS) - 1)) >> (FAST_BITS - magbits); + int m = 1 << (magbits - 1); + if (k < m) k += (~0U << magbits) + 1; + // if the result is small enough, we can fit it in fast_ac table + if (k >= -128 && k <= 127) + fast_ac[i] = (stbi__int16) ((k * 256) + (run * 16) + (len + magbits)); + } + } + } +} + +static void stbi__grow_buffer_unsafe(stbi__jpeg *j) +{ + do { + unsigned int b = j->nomore ? 0 : stbi__get8(j->s); + if (b == 0xff) { + int c = stbi__get8(j->s); + while (c == 0xff) c = stbi__get8(j->s); // consume fill bytes + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static const stbi__uint32 stbi__bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +stbi_inline static int stbi__jpeg_huff_decode(stbi__jpeg *j, stbi__huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & stbi__bmask[k]) + h->delta[k]; + if(c < 0 || c >= 256) // symbol id out of bounds! + return -1; + STBI_ASSERT((((j->code_buffer) >> (32 - h->size[c])) & stbi__bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// bias[n] = (-1<code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + + sgn = j->code_buffer >> 31; // sign bit always in MSB; 0 if MSB clear (positive), 1 if MSB set (negative) + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k + (stbi__jbias[n] & (sgn - 1)); +} + +// get some unsigned bits +stbi_inline static int stbi__jpeg_get_bits(stbi__jpeg *j, int n) +{ + unsigned int k; + if (j->code_bits < n) stbi__grow_buffer_unsafe(j); + if (j->code_bits < n) return 0; // ran out of bits from stream, return 0s intead of continuing + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~stbi__bmask[n]; + k &= stbi__bmask[n]; + j->code_bits -= n; + return k; +} + +stbi_inline static int stbi__jpeg_get_bit(stbi__jpeg *j) +{ + unsigned int k; + if (j->code_bits < 1) stbi__grow_buffer_unsafe(j); + if (j->code_bits < 1) return 0; // ran out of bits from stream, return 0s intead of continuing + k = j->code_buffer; + j->code_buffer <<= 1; + --j->code_bits; + return k & 0x80000000; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static const stbi_uc stbi__jpeg_dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int stbi__jpeg_decode_block(stbi__jpeg *j, short data[64], stbi__huffman *hdc, stbi__huffman *hac, stbi__int16 *fac, int b, stbi__uint16 *dequant) +{ + int diff,dc,k; + int t; + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? stbi__extend_receive(j, t) : 0; + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta","Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, dequant[0])) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * dequant[0]); + + // decode AC components, see JPEG spec + k = 1; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * dequant[zig]); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * dequant[zig]); + } + } + } while (k < 64); + return 1; +} + +static int stbi__jpeg_decode_block_prog_dc(stbi__jpeg *j, short data[64], stbi__huffman *hdc, int b) +{ + int diff,dc; + int t; + if (j->spec_end != 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + + if (j->succ_high == 0) { + // first scan for DC coefficient, must be first + memset(data,0,64*sizeof(data[0])); // 0 all the ac values now + t = stbi__jpeg_huff_decode(j, hdc); + if (t < 0 || t > 15) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + diff = t ? stbi__extend_receive(j, t) : 0; + + if (!stbi__addints_valid(j->img_comp[b].dc_pred, diff)) return stbi__err("bad delta", "Corrupt JPEG"); + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + if (!stbi__mul2shorts_valid(dc, 1 << j->succ_low)) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + data[0] = (short) (dc * (1 << j->succ_low)); + } else { + // refinement scan for DC coefficient + if (stbi__jpeg_get_bit(j)) + data[0] += (short) (1 << j->succ_low); + } + return 1; +} + +// @OPTIMIZE: store non-zigzagged during the decode passes, +// and only de-zigzag when dequantizing +static int stbi__jpeg_decode_block_prog_ac(stbi__jpeg *j, short data[64], stbi__huffman *hac, stbi__int16 *fac) +{ + int k; + if (j->spec_start == 0) return stbi__err("can't merge dc and ac", "Corrupt JPEG"); + + if (j->succ_high == 0) { + int shift = j->succ_low; + + if (j->eob_run) { + --j->eob_run; + return 1; + } + + k = j->spec_start; + do { + unsigned int zig; + int c,r,s; + if (j->code_bits < 16) stbi__grow_buffer_unsafe(j); + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + r = fac[c]; + if (r) { // fast-AC path + k += (r >> 4) & 15; // run + s = r & 15; // combined length + if (s > j->code_bits) return stbi__err("bad huffman code", "Combined length longer than code bits available"); + j->code_buffer <<= s; + j->code_bits -= s; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) ((r >> 8) * (1 << shift)); + } else { + int rs = stbi__jpeg_huff_decode(j, hac); + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r); + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + --j->eob_run; + break; + } + k += 16; + } else { + k += r; + zig = stbi__jpeg_dezigzag[k++]; + data[zig] = (short) (stbi__extend_receive(j,s) * (1 << shift)); + } + } + } while (k <= j->spec_end); + } else { + // refinement scan for these AC coefficients + + short bit = (short) (1 << j->succ_low); + + if (j->eob_run) { + --j->eob_run; + for (k = j->spec_start; k <= j->spec_end; ++k) { + short *p = &data[stbi__jpeg_dezigzag[k]]; + if (*p != 0) + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } + } else { + k = j->spec_start; + do { + int r,s; + int rs = stbi__jpeg_huff_decode(j, hac); // @OPTIMIZE see if we can use the fast path here, advance-by-r is so slow, eh + if (rs < 0) return stbi__err("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (r < 15) { + j->eob_run = (1 << r) - 1; + if (r) + j->eob_run += stbi__jpeg_get_bits(j, r); + r = 64; // force end of block + } else { + // r=15 s=0 should write 16 0s, so we just do + // a run of 15 0s and then write s (which is 0), + // so we don't have to do anything special here + } + } else { + if (s != 1) return stbi__err("bad huffman code", "Corrupt JPEG"); + // sign bit + if (stbi__jpeg_get_bit(j)) + s = bit; + else + s = -bit; + } + + // advance by r + while (k <= j->spec_end) { + short *p = &data[stbi__jpeg_dezigzag[k++]]; + if (*p != 0) { + if (stbi__jpeg_get_bit(j)) + if ((*p & bit)==0) { + if (*p > 0) + *p += bit; + else + *p -= bit; + } + } else { + if (r == 0) { + *p = (short) s; + break; + } + --r; + } + } + } while (k <= j->spec_end); + } + } + return 1; +} + +// take a -128..127 value and stbi__clamp it and convert to 0..255 +stbi_inline static stbi_uc stbi__clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (stbi_uc) x; +} + +#define stbi__f2f(x) ((int) (((x) * 4096 + 0.5))) +#define stbi__fsh(x) ((x) * 4096) + +// derived from jidctint -- DCT_ISLOW +#define STBI__IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * stbi__f2f(0.5411961f); \ + t2 = p1 + p3*stbi__f2f(-1.847759065f); \ + t3 = p1 + p2*stbi__f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = stbi__fsh(p2+p3); \ + t1 = stbi__fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*stbi__f2f( 1.175875602f); \ + t0 = t0*stbi__f2f( 0.298631336f); \ + t1 = t1*stbi__f2f( 2.053119869f); \ + t2 = t2*stbi__f2f( 3.072711026f); \ + t3 = t3*stbi__f2f( 1.501321110f); \ + p1 = p5 + p1*stbi__f2f(-0.899976223f); \ + p2 = p5 + p2*stbi__f2f(-2.562915447f); \ + p3 = p3*stbi__f2f(-1.961570560f); \ + p4 = p4*stbi__f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +static void stbi__idct_block(stbi_uc *out, int out_stride, short data[64]) +{ + int i,val[64],*v=val; + stbi_uc *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0]*4; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + STBI__IDCT_1D(d[ 0],d[ 8],d[16],d[24],d[32],d[40],d[48],d[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + STBI__IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = stbi__clamp((x0+t3) >> 17); + o[7] = stbi__clamp((x0-t3) >> 17); + o[1] = stbi__clamp((x1+t2) >> 17); + o[6] = stbi__clamp((x1-t2) >> 17); + o[2] = stbi__clamp((x2+t1) >> 17); + o[5] = stbi__clamp((x2-t1) >> 17); + o[3] = stbi__clamp((x3+t0) >> 17); + o[4] = stbi__clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SSE2 +// sse2 integer IDCT. not the fastest possible implementation but it +// produces bit-identical results to the generic C version so it's +// fully "transparent". +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + // This is constructed to match our regular (generic) integer IDCT exactly. + __m128i row0, row1, row2, row3, row4, row5, row6, row7; + __m128i tmp; + + // dot product constant: even elems=x, odd elems=y + #define dct_const(x,y) _mm_setr_epi16((x),(y),(x),(y),(x),(y),(x),(y)) + + // out(0) = c0[even]*x + c0[odd]*y (c0, x, y 16-bit, out 32-bit) + // out(1) = c1[even]*x + c1[odd]*y + #define dct_rot(out0,out1, x,y,c0,c1) \ + __m128i c0##lo = _mm_unpacklo_epi16((x),(y)); \ + __m128i c0##hi = _mm_unpackhi_epi16((x),(y)); \ + __m128i out0##_l = _mm_madd_epi16(c0##lo, c0); \ + __m128i out0##_h = _mm_madd_epi16(c0##hi, c0); \ + __m128i out1##_l = _mm_madd_epi16(c0##lo, c1); \ + __m128i out1##_h = _mm_madd_epi16(c0##hi, c1) + + // out = in << 12 (in 16-bit, out 32-bit) + #define dct_widen(out, in) \ + __m128i out##_l = _mm_srai_epi32(_mm_unpacklo_epi16(_mm_setzero_si128(), (in)), 4); \ + __m128i out##_h = _mm_srai_epi32(_mm_unpackhi_epi16(_mm_setzero_si128(), (in)), 4) + + // wide add + #define dct_wadd(out, a, b) \ + __m128i out##_l = _mm_add_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_add_epi32(a##_h, b##_h) + + // wide sub + #define dct_wsub(out, a, b) \ + __m128i out##_l = _mm_sub_epi32(a##_l, b##_l); \ + __m128i out##_h = _mm_sub_epi32(a##_h, b##_h) + + // butterfly a/b, add bias, then shift by "s" and pack + #define dct_bfly32o(out0, out1, a,b,bias,s) \ + { \ + __m128i abiased_l = _mm_add_epi32(a##_l, bias); \ + __m128i abiased_h = _mm_add_epi32(a##_h, bias); \ + dct_wadd(sum, abiased, b); \ + dct_wsub(dif, abiased, b); \ + out0 = _mm_packs_epi32(_mm_srai_epi32(sum_l, s), _mm_srai_epi32(sum_h, s)); \ + out1 = _mm_packs_epi32(_mm_srai_epi32(dif_l, s), _mm_srai_epi32(dif_h, s)); \ + } + + // 8-bit interleave step (for transposes) + #define dct_interleave8(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi8(a, b); \ + b = _mm_unpackhi_epi8(tmp, b) + + // 16-bit interleave step (for transposes) + #define dct_interleave16(a, b) \ + tmp = a; \ + a = _mm_unpacklo_epi16(a, b); \ + b = _mm_unpackhi_epi16(tmp, b) + + #define dct_pass(bias,shift) \ + { \ + /* even part */ \ + dct_rot(t2e,t3e, row2,row6, rot0_0,rot0_1); \ + __m128i sum04 = _mm_add_epi16(row0, row4); \ + __m128i dif04 = _mm_sub_epi16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + dct_rot(y0o,y2o, row7,row3, rot2_0,rot2_1); \ + dct_rot(y1o,y3o, row5,row1, rot3_0,rot3_1); \ + __m128i sum17 = _mm_add_epi16(row1, row7); \ + __m128i sum35 = _mm_add_epi16(row3, row5); \ + dct_rot(y4o,y5o, sum17,sum35, rot1_0,rot1_1); \ + dct_wadd(x4, y0o, y4o); \ + dct_wadd(x5, y1o, y5o); \ + dct_wadd(x6, y2o, y5o); \ + dct_wadd(x7, y3o, y4o); \ + dct_bfly32o(row0,row7, x0,x7,bias,shift); \ + dct_bfly32o(row1,row6, x1,x6,bias,shift); \ + dct_bfly32o(row2,row5, x2,x5,bias,shift); \ + dct_bfly32o(row3,row4, x3,x4,bias,shift); \ + } + + __m128i rot0_0 = dct_const(stbi__f2f(0.5411961f), stbi__f2f(0.5411961f) + stbi__f2f(-1.847759065f)); + __m128i rot0_1 = dct_const(stbi__f2f(0.5411961f) + stbi__f2f( 0.765366865f), stbi__f2f(0.5411961f)); + __m128i rot1_0 = dct_const(stbi__f2f(1.175875602f) + stbi__f2f(-0.899976223f), stbi__f2f(1.175875602f)); + __m128i rot1_1 = dct_const(stbi__f2f(1.175875602f), stbi__f2f(1.175875602f) + stbi__f2f(-2.562915447f)); + __m128i rot2_0 = dct_const(stbi__f2f(-1.961570560f) + stbi__f2f( 0.298631336f), stbi__f2f(-1.961570560f)); + __m128i rot2_1 = dct_const(stbi__f2f(-1.961570560f), stbi__f2f(-1.961570560f) + stbi__f2f( 3.072711026f)); + __m128i rot3_0 = dct_const(stbi__f2f(-0.390180644f) + stbi__f2f( 2.053119869f), stbi__f2f(-0.390180644f)); + __m128i rot3_1 = dct_const(stbi__f2f(-0.390180644f), stbi__f2f(-0.390180644f) + stbi__f2f( 1.501321110f)); + + // rounding biases in column/row passes, see stbi__idct_block for explanation. + __m128i bias_0 = _mm_set1_epi32(512); + __m128i bias_1 = _mm_set1_epi32(65536 + (128<<17)); + + // load + row0 = _mm_load_si128((const __m128i *) (data + 0*8)); + row1 = _mm_load_si128((const __m128i *) (data + 1*8)); + row2 = _mm_load_si128((const __m128i *) (data + 2*8)); + row3 = _mm_load_si128((const __m128i *) (data + 3*8)); + row4 = _mm_load_si128((const __m128i *) (data + 4*8)); + row5 = _mm_load_si128((const __m128i *) (data + 5*8)); + row6 = _mm_load_si128((const __m128i *) (data + 6*8)); + row7 = _mm_load_si128((const __m128i *) (data + 7*8)); + + // column pass + dct_pass(bias_0, 10); + + { + // 16bit 8x8 transpose pass 1 + dct_interleave16(row0, row4); + dct_interleave16(row1, row5); + dct_interleave16(row2, row6); + dct_interleave16(row3, row7); + + // transpose pass 2 + dct_interleave16(row0, row2); + dct_interleave16(row1, row3); + dct_interleave16(row4, row6); + dct_interleave16(row5, row7); + + // transpose pass 3 + dct_interleave16(row0, row1); + dct_interleave16(row2, row3); + dct_interleave16(row4, row5); + dct_interleave16(row6, row7); + } + + // row pass + dct_pass(bias_1, 17); + + { + // pack + __m128i p0 = _mm_packus_epi16(row0, row1); // a0a1a2a3...a7b0b1b2b3...b7 + __m128i p1 = _mm_packus_epi16(row2, row3); + __m128i p2 = _mm_packus_epi16(row4, row5); + __m128i p3 = _mm_packus_epi16(row6, row7); + + // 8bit 8x8 transpose pass 1 + dct_interleave8(p0, p2); // a0e0a1e1... + dct_interleave8(p1, p3); // c0g0c1g1... + + // transpose pass 2 + dct_interleave8(p0, p1); // a0c0e0g0... + dct_interleave8(p2, p3); // b0d0f0h0... + + // transpose pass 3 + dct_interleave8(p0, p2); // a0b0c0d0... + dct_interleave8(p1, p3); // a4b4c4d4... + + // store + _mm_storel_epi64((__m128i *) out, p0); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p0, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p2); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p2, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p1); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p1, 0x4e)); out += out_stride; + _mm_storel_epi64((__m128i *) out, p3); out += out_stride; + _mm_storel_epi64((__m128i *) out, _mm_shuffle_epi32(p3, 0x4e)); + } + +#undef dct_const +#undef dct_rot +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_interleave8 +#undef dct_interleave16 +#undef dct_pass +} + +#endif // STBI_SSE2 + +#ifdef STBI_NEON + +// NEON integer IDCT. should produce bit-identical +// results to the generic C version. +static void stbi__idct_simd(stbi_uc *out, int out_stride, short data[64]) +{ + int16x8_t row0, row1, row2, row3, row4, row5, row6, row7; + + int16x4_t rot0_0 = vdup_n_s16(stbi__f2f(0.5411961f)); + int16x4_t rot0_1 = vdup_n_s16(stbi__f2f(-1.847759065f)); + int16x4_t rot0_2 = vdup_n_s16(stbi__f2f( 0.765366865f)); + int16x4_t rot1_0 = vdup_n_s16(stbi__f2f( 1.175875602f)); + int16x4_t rot1_1 = vdup_n_s16(stbi__f2f(-0.899976223f)); + int16x4_t rot1_2 = vdup_n_s16(stbi__f2f(-2.562915447f)); + int16x4_t rot2_0 = vdup_n_s16(stbi__f2f(-1.961570560f)); + int16x4_t rot2_1 = vdup_n_s16(stbi__f2f(-0.390180644f)); + int16x4_t rot3_0 = vdup_n_s16(stbi__f2f( 0.298631336f)); + int16x4_t rot3_1 = vdup_n_s16(stbi__f2f( 2.053119869f)); + int16x4_t rot3_2 = vdup_n_s16(stbi__f2f( 3.072711026f)); + int16x4_t rot3_3 = vdup_n_s16(stbi__f2f( 1.501321110f)); + +#define dct_long_mul(out, inq, coeff) \ + int32x4_t out##_l = vmull_s16(vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmull_s16(vget_high_s16(inq), coeff) + +#define dct_long_mac(out, acc, inq, coeff) \ + int32x4_t out##_l = vmlal_s16(acc##_l, vget_low_s16(inq), coeff); \ + int32x4_t out##_h = vmlal_s16(acc##_h, vget_high_s16(inq), coeff) + +#define dct_widen(out, inq) \ + int32x4_t out##_l = vshll_n_s16(vget_low_s16(inq), 12); \ + int32x4_t out##_h = vshll_n_s16(vget_high_s16(inq), 12) + +// wide add +#define dct_wadd(out, a, b) \ + int32x4_t out##_l = vaddq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vaddq_s32(a##_h, b##_h) + +// wide sub +#define dct_wsub(out, a, b) \ + int32x4_t out##_l = vsubq_s32(a##_l, b##_l); \ + int32x4_t out##_h = vsubq_s32(a##_h, b##_h) + +// butterfly a/b, then shift using "shiftop" by "s" and pack +#define dct_bfly32o(out0,out1, a,b,shiftop,s) \ + { \ + dct_wadd(sum, a, b); \ + dct_wsub(dif, a, b); \ + out0 = vcombine_s16(shiftop(sum_l, s), shiftop(sum_h, s)); \ + out1 = vcombine_s16(shiftop(dif_l, s), shiftop(dif_h, s)); \ + } + +#define dct_pass(shiftop, shift) \ + { \ + /* even part */ \ + int16x8_t sum26 = vaddq_s16(row2, row6); \ + dct_long_mul(p1e, sum26, rot0_0); \ + dct_long_mac(t2e, p1e, row6, rot0_1); \ + dct_long_mac(t3e, p1e, row2, rot0_2); \ + int16x8_t sum04 = vaddq_s16(row0, row4); \ + int16x8_t dif04 = vsubq_s16(row0, row4); \ + dct_widen(t0e, sum04); \ + dct_widen(t1e, dif04); \ + dct_wadd(x0, t0e, t3e); \ + dct_wsub(x3, t0e, t3e); \ + dct_wadd(x1, t1e, t2e); \ + dct_wsub(x2, t1e, t2e); \ + /* odd part */ \ + int16x8_t sum15 = vaddq_s16(row1, row5); \ + int16x8_t sum17 = vaddq_s16(row1, row7); \ + int16x8_t sum35 = vaddq_s16(row3, row5); \ + int16x8_t sum37 = vaddq_s16(row3, row7); \ + int16x8_t sumodd = vaddq_s16(sum17, sum35); \ + dct_long_mul(p5o, sumodd, rot1_0); \ + dct_long_mac(p1o, p5o, sum17, rot1_1); \ + dct_long_mac(p2o, p5o, sum35, rot1_2); \ + dct_long_mul(p3o, sum37, rot2_0); \ + dct_long_mul(p4o, sum15, rot2_1); \ + dct_wadd(sump13o, p1o, p3o); \ + dct_wadd(sump24o, p2o, p4o); \ + dct_wadd(sump23o, p2o, p3o); \ + dct_wadd(sump14o, p1o, p4o); \ + dct_long_mac(x4, sump13o, row7, rot3_0); \ + dct_long_mac(x5, sump24o, row5, rot3_1); \ + dct_long_mac(x6, sump23o, row3, rot3_2); \ + dct_long_mac(x7, sump14o, row1, rot3_3); \ + dct_bfly32o(row0,row7, x0,x7,shiftop,shift); \ + dct_bfly32o(row1,row6, x1,x6,shiftop,shift); \ + dct_bfly32o(row2,row5, x2,x5,shiftop,shift); \ + dct_bfly32o(row3,row4, x3,x4,shiftop,shift); \ + } + + // load + row0 = vld1q_s16(data + 0*8); + row1 = vld1q_s16(data + 1*8); + row2 = vld1q_s16(data + 2*8); + row3 = vld1q_s16(data + 3*8); + row4 = vld1q_s16(data + 4*8); + row5 = vld1q_s16(data + 5*8); + row6 = vld1q_s16(data + 6*8); + row7 = vld1q_s16(data + 7*8); + + // add DC bias + row0 = vaddq_s16(row0, vsetq_lane_s16(1024, vdupq_n_s16(0), 0)); + + // column pass + dct_pass(vrshrn_n_s32, 10); + + // 16bit 8x8 transpose + { +// these three map to a single VTRN.16, VTRN.32, and VSWP, respectively. +// whether compilers actually get this is another story, sadly. +#define dct_trn16(x, y) { int16x8x2_t t = vtrnq_s16(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn32(x, y) { int32x4x2_t t = vtrnq_s32(vreinterpretq_s32_s16(x), vreinterpretq_s32_s16(y)); x = vreinterpretq_s16_s32(t.val[0]); y = vreinterpretq_s16_s32(t.val[1]); } +#define dct_trn64(x, y) { int16x8_t x0 = x; int16x8_t y0 = y; x = vcombine_s16(vget_low_s16(x0), vget_low_s16(y0)); y = vcombine_s16(vget_high_s16(x0), vget_high_s16(y0)); } + + // pass 1 + dct_trn16(row0, row1); // a0b0a2b2a4b4a6b6 + dct_trn16(row2, row3); + dct_trn16(row4, row5); + dct_trn16(row6, row7); + + // pass 2 + dct_trn32(row0, row2); // a0b0c0d0a4b4c4d4 + dct_trn32(row1, row3); + dct_trn32(row4, row6); + dct_trn32(row5, row7); + + // pass 3 + dct_trn64(row0, row4); // a0b0c0d0e0f0g0h0 + dct_trn64(row1, row5); + dct_trn64(row2, row6); + dct_trn64(row3, row7); + +#undef dct_trn16 +#undef dct_trn32 +#undef dct_trn64 + } + + // row pass + // vrshrn_n_s32 only supports shifts up to 16, we need + // 17. so do a non-rounding shift of 16 first then follow + // up with a rounding shift by 1. + dct_pass(vshrn_n_s32, 16); + + { + // pack and round + uint8x8_t p0 = vqrshrun_n_s16(row0, 1); + uint8x8_t p1 = vqrshrun_n_s16(row1, 1); + uint8x8_t p2 = vqrshrun_n_s16(row2, 1); + uint8x8_t p3 = vqrshrun_n_s16(row3, 1); + uint8x8_t p4 = vqrshrun_n_s16(row4, 1); + uint8x8_t p5 = vqrshrun_n_s16(row5, 1); + uint8x8_t p6 = vqrshrun_n_s16(row6, 1); + uint8x8_t p7 = vqrshrun_n_s16(row7, 1); + + // again, these can translate into one instruction, but often don't. +#define dct_trn8_8(x, y) { uint8x8x2_t t = vtrn_u8(x, y); x = t.val[0]; y = t.val[1]; } +#define dct_trn8_16(x, y) { uint16x4x2_t t = vtrn_u16(vreinterpret_u16_u8(x), vreinterpret_u16_u8(y)); x = vreinterpret_u8_u16(t.val[0]); y = vreinterpret_u8_u16(t.val[1]); } +#define dct_trn8_32(x, y) { uint32x2x2_t t = vtrn_u32(vreinterpret_u32_u8(x), vreinterpret_u32_u8(y)); x = vreinterpret_u8_u32(t.val[0]); y = vreinterpret_u8_u32(t.val[1]); } + + // sadly can't use interleaved stores here since we only write + // 8 bytes to each scan line! + + // 8x8 8-bit transpose pass 1 + dct_trn8_8(p0, p1); + dct_trn8_8(p2, p3); + dct_trn8_8(p4, p5); + dct_trn8_8(p6, p7); + + // pass 2 + dct_trn8_16(p0, p2); + dct_trn8_16(p1, p3); + dct_trn8_16(p4, p6); + dct_trn8_16(p5, p7); + + // pass 3 + dct_trn8_32(p0, p4); + dct_trn8_32(p1, p5); + dct_trn8_32(p2, p6); + dct_trn8_32(p3, p7); + + // store + vst1_u8(out, p0); out += out_stride; + vst1_u8(out, p1); out += out_stride; + vst1_u8(out, p2); out += out_stride; + vst1_u8(out, p3); out += out_stride; + vst1_u8(out, p4); out += out_stride; + vst1_u8(out, p5); out += out_stride; + vst1_u8(out, p6); out += out_stride; + vst1_u8(out, p7); + +#undef dct_trn8_8 +#undef dct_trn8_16 +#undef dct_trn8_32 + } + +#undef dct_long_mul +#undef dct_long_mac +#undef dct_widen +#undef dct_wadd +#undef dct_wsub +#undef dct_bfly32o +#undef dct_pass +} + +#endif // STBI_NEON + +#define STBI__MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static stbi_uc stbi__get_marker(stbi__jpeg *j) +{ + stbi_uc x; + if (j->marker != STBI__MARKER_none) { x = j->marker; j->marker = STBI__MARKER_none; return x; } + x = stbi__get8(j->s); + if (x != 0xff) return STBI__MARKER_none; + while (x == 0xff) + x = stbi__get8(j->s); // consume repeated 0xff fill bytes + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define STBI__RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, stbi__jpeg_reset the entropy decoder and +// the dc prediction +static void stbi__jpeg_reset(stbi__jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = j->img_comp[3].dc_pred = 0; + j->marker = STBI__MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + j->eob_run = 0; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int stbi__parse_entropy_coded_data(stbi__jpeg *z) +{ + stbi__jpeg_reset(z); + if (!z->progressive) { + if (z->scan_n == 1) { + int i,j; + STBI_SIMD_ALIGN(short, data[64]); + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + STBI_SIMD_ALIGN(short, data[64]); + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+ha, z->fast_ac[ha], n, z->dequant[z->img_comp[n].tq])) return 0; + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data); + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } else { + if (z->scan_n == 1) { + int i,j; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + if (z->spec_start == 0) { + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } else { + int ha = z->img_comp[n].ha; + if (!stbi__jpeg_decode_block_prog_ac(z, data, &z->huff_ac[ha], z->fast_ac[ha])) + return 0; + } + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } else { // interleaved + int i,j,k,x,y; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x); + int y2 = (j*z->img_comp[n].v + y); + short *data = z->img_comp[n].coeff + 64 * (x2 + y2 * z->img_comp[n].coeff_w); + if (!stbi__jpeg_decode_block_prog_dc(z, data, &z->huff_dc[z->img_comp[n].hd], n)) + return 0; + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) stbi__grow_buffer_unsafe(z); + if (!STBI__RESTART(z->marker)) return 1; + stbi__jpeg_reset(z); + } + } + } + return 1; + } + } +} + +static void stbi__jpeg_dequantize(short *data, stbi__uint16 *dequant) +{ + int i; + for (i=0; i < 64; ++i) + data[i] *= dequant[i]; +} + +static void stbi__jpeg_finish(stbi__jpeg *z) +{ + if (z->progressive) { + // dequantize and idct the data + int i,j,n; + for (n=0; n < z->s->img_n; ++n) { + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + short *data = z->img_comp[n].coeff + 64 * (i + j * z->img_comp[n].coeff_w); + stbi__jpeg_dequantize(data, z->dequant[z->img_comp[n].tq]); + z->idct_block_kernel(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data); + } + } + } + } +} + +static int stbi__process_marker(stbi__jpeg *z, int m) +{ + int L; + switch (m) { + case STBI__MARKER_none: // no marker found + return stbi__err("expected marker","Corrupt JPEG"); + + case 0xDD: // DRI - specify restart interval + if (stbi__get16be(z->s) != 4) return stbi__err("bad DRI len","Corrupt JPEG"); + z->restart_interval = stbi__get16be(z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = stbi__get16be(z->s)-2; + while (L > 0) { + int q = stbi__get8(z->s); + int p = q >> 4, sixteen = (p != 0); + int t = q & 15,i; + if (p != 0 && p != 1) return stbi__err("bad DQT type","Corrupt JPEG"); + if (t > 3) return stbi__err("bad DQT table","Corrupt JPEG"); + + for (i=0; i < 64; ++i) + z->dequant[t][stbi__jpeg_dezigzag[i]] = (stbi__uint16)(sixteen ? stbi__get16be(z->s) : stbi__get8(z->s)); + L -= (sixteen ? 129 : 65); + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = stbi__get16be(z->s)-2; + while (L > 0) { + stbi_uc *v; + int sizes[16],i,n=0; + int q = stbi__get8(z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return stbi__err("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = stbi__get8(z->s); + n += sizes[i]; + } + if(n > 256) return stbi__err("bad DHT header","Corrupt JPEG"); // Loop over i < n would write past end of values! + L -= 17; + if (tc == 0) { + if (!stbi__build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!stbi__build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < n; ++i) + v[i] = stbi__get8(z->s); + if (tc != 0) + stbi__build_fast_ac(z->fast_ac[th], z->huff_ac + th); + L -= n; + } + return L==0; + } + + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + L = stbi__get16be(z->s); + if (L < 2) { + if (m == 0xFE) + return stbi__err("bad COM len","Corrupt JPEG"); + else + return stbi__err("bad APP len","Corrupt JPEG"); + } + L -= 2; + + if (m == 0xE0 && L >= 5) { // JFIF APP0 segment + static const unsigned char tag[5] = {'J','F','I','F','\0'}; + int ok = 1; + int i; + for (i=0; i < 5; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 5; + if (ok) + z->jfif = 1; + } else if (m == 0xEE && L >= 12) { // Adobe APP14 segment + static const unsigned char tag[6] = {'A','d','o','b','e','\0'}; + int ok = 1; + int i; + for (i=0; i < 6; ++i) + if (stbi__get8(z->s) != tag[i]) + ok = 0; + L -= 6; + if (ok) { + stbi__get8(z->s); // version + stbi__get16be(z->s); // flags0 + stbi__get16be(z->s); // flags1 + z->app14_color_transform = stbi__get8(z->s); // color transform + L -= 6; + } + } + + stbi__skip(z->s, L); + return 1; + } + + return stbi__err("unknown marker","Corrupt JPEG"); +} + +// after we see SOS +static int stbi__process_scan_header(stbi__jpeg *z) +{ + int i; + int Ls = stbi__get16be(z->s); + z->scan_n = stbi__get8(z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s->img_n) return stbi__err("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return stbi__err("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = stbi__get8(z->s), which; + int q = stbi__get8(z->s); + for (which = 0; which < z->s->img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s->img_n) return 0; // no match + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return stbi__err("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return stbi__err("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + + { + int aa; + z->spec_start = stbi__get8(z->s); + z->spec_end = stbi__get8(z->s); // should be 63, but might be 0 + aa = stbi__get8(z->s); + z->succ_high = (aa >> 4); + z->succ_low = (aa & 15); + if (z->progressive) { + if (z->spec_start > 63 || z->spec_end > 63 || z->spec_start > z->spec_end || z->succ_high > 13 || z->succ_low > 13) + return stbi__err("bad SOS", "Corrupt JPEG"); + } else { + if (z->spec_start != 0) return stbi__err("bad SOS","Corrupt JPEG"); + if (z->succ_high != 0 || z->succ_low != 0) return stbi__err("bad SOS","Corrupt JPEG"); + z->spec_end = 63; + } + } + + return 1; +} + +static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why) +{ + int i; + for (i=0; i < ncomp; ++i) { + if (z->img_comp[i].raw_data) { + STBI_FREE(z->img_comp[i].raw_data); + z->img_comp[i].raw_data = NULL; + z->img_comp[i].data = NULL; + } + if (z->img_comp[i].raw_coeff) { + STBI_FREE(z->img_comp[i].raw_coeff); + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].coeff = 0; + } + if (z->img_comp[i].linebuf) { + STBI_FREE(z->img_comp[i].linebuf); + z->img_comp[i].linebuf = NULL; + } + } + return why; +} + +static int stbi__process_frame_header(stbi__jpeg *z, int scan) +{ + stbi__context *s = z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG + p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = stbi__get16be(s); if (s->img_y == 0) return stbi__err("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = stbi__get16be(s); if (s->img_x == 0) return stbi__err("0 width","Corrupt JPEG"); // JPEG requires + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + c = stbi__get8(s); + if (c != 3 && c != 1 && c != 4) return stbi__err("bad component count","Corrupt JPEG"); + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return stbi__err("bad SOF len","Corrupt JPEG"); + + z->rgb = 0; + for (i=0; i < s->img_n; ++i) { + static const unsigned char rgb[3] = { 'R', 'G', 'B' }; + z->img_comp[i].id = stbi__get8(s); + if (s->img_n == 3 && z->img_comp[i].id == rgb[i]) + ++z->rgb; + q = stbi__get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return stbi__err("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return stbi__err("bad V","Corrupt JPEG"); + z->img_comp[i].tq = stbi__get8(s); if (z->img_comp[i].tq > 3) return stbi__err("bad TQ","Corrupt JPEG"); + } + + if (scan != STBI__SCAN_load) return 1; + + if (!stbi__mad3sizes_valid(s->img_x, s->img_y, s->img_n, 0)) return stbi__err("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // check that plane subsampling factors are integer ratios; our resamplers can't deal with fractional ratios + // and I've never seen a non-corrupted JPEG file actually use them + for (i=0; i < s->img_n; ++i) { + if (h_max % z->img_comp[i].h != 0) return stbi__err("bad H","Corrupt JPEG"); + if (v_max % z->img_comp[i].v != 0) return stbi__err("bad V","Corrupt JPEG"); + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + // these sizes can't be more than 17 bits + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + // + // img_mcu_x, img_mcu_y: <=17 bits; comp[i].h and .v are <=4 (checked earlier) + // so these muls can't overflow with 32-bit ints (which we require) + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].coeff = 0; + z->img_comp[i].raw_coeff = 0; + z->img_comp[i].linebuf = NULL; + z->img_comp[i].raw_data = stbi__malloc_mad2(z->img_comp[i].w2, z->img_comp[i].h2, 15); + if (z->img_comp[i].raw_data == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + // align blocks for idct using mmx/sse + z->img_comp[i].data = (stbi_uc*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + if (z->progressive) { + // w2, h2 are multiples of 8 (see above) + z->img_comp[i].coeff_w = z->img_comp[i].w2 / 8; + z->img_comp[i].coeff_h = z->img_comp[i].h2 / 8; + z->img_comp[i].raw_coeff = stbi__malloc_mad3(z->img_comp[i].w2, z->img_comp[i].h2, sizeof(short), 15); + if (z->img_comp[i].raw_coeff == NULL) + return stbi__free_jpeg_components(z, i+1, stbi__err("outofmem", "Out of memory")); + z->img_comp[i].coeff = (short*) (((size_t) z->img_comp[i].raw_coeff + 15) & ~15); + } + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define stbi__DNL(x) ((x) == 0xdc) +#define stbi__SOI(x) ((x) == 0xd8) +#define stbi__EOI(x) ((x) == 0xd9) +#define stbi__SOF(x) ((x) == 0xc0 || (x) == 0xc1 || (x) == 0xc2) +#define stbi__SOS(x) ((x) == 0xda) + +#define stbi__SOF_progressive(x) ((x) == 0xc2) + +static int stbi__decode_jpeg_header(stbi__jpeg *z, int scan) +{ + int m; + z->jfif = 0; + z->app14_color_transform = -1; // valid values are 0,1,2 + z->marker = STBI__MARKER_none; // initialize cached marker to empty + m = stbi__get_marker(z); + if (!stbi__SOI(m)) return stbi__err("no SOI","Corrupt JPEG"); + if (scan == STBI__SCAN_type) return 1; + m = stbi__get_marker(z); + while (!stbi__SOF(m)) { + if (!stbi__process_marker(z,m)) return 0; + m = stbi__get_marker(z); + while (m == STBI__MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (stbi__at_eof(z->s)) return stbi__err("no SOF", "Corrupt JPEG"); + m = stbi__get_marker(z); + } + } + z->progressive = stbi__SOF_progressive(m); + if (!stbi__process_frame_header(z, scan)) return 0; + return 1; +} + +static stbi_uc stbi__skip_jpeg_junk_at_end(stbi__jpeg *j) +{ + // some JPEGs have junk at end, skip over it but if we find what looks + // like a valid marker, resume there + while (!stbi__at_eof(j->s)) { + stbi_uc x = stbi__get8(j->s); + while (x == 0xff) { // might be a marker + if (stbi__at_eof(j->s)) return STBI__MARKER_none; + x = stbi__get8(j->s); + if (x != 0x00 && x != 0xff) { + // not a stuffed zero or lead-in to another marker, looks + // like an actual marker, return it + return x; + } + // stuffed zero has x=0 now which ends the loop, meaning we go + // back to regular scan loop. + // repeated 0xff keeps trying to read the next byte of the marker. + } + } + return STBI__MARKER_none; +} + +// decode image to YCbCr format +static int stbi__decode_jpeg_image(stbi__jpeg *j) +{ + int m; + for (m = 0; m < 4; m++) { + j->img_comp[m].raw_data = NULL; + j->img_comp[m].raw_coeff = NULL; + } + j->restart_interval = 0; + if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0; + m = stbi__get_marker(j); + while (!stbi__EOI(m)) { + if (stbi__SOS(m)) { + if (!stbi__process_scan_header(j)) return 0; + if (!stbi__parse_entropy_coded_data(j)) return 0; + if (j->marker == STBI__MARKER_none ) { + j->marker = stbi__skip_jpeg_junk_at_end(j); + // if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0 + } + m = stbi__get_marker(j); + if (STBI__RESTART(m)) + m = stbi__get_marker(j); + } else if (stbi__DNL(m)) { + int Ld = stbi__get16be(j->s); + stbi__uint32 NL = stbi__get16be(j->s); + if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG"); + if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG"); + m = stbi__get_marker(j); + } else { + if (!stbi__process_marker(j, m)) return 1; + m = stbi__get_marker(j); + } + } + if (j->progressive) + stbi__jpeg_finish(j); + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef stbi_uc *(*resample_row_func)(stbi_uc *out, stbi_uc *in0, stbi_uc *in1, + int w, int hs); + +#define stbi__div4(x) ((stbi_uc) ((x) >> 2)) + +static stbi_uc *resample_row_1(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static stbi_uc* stbi__resample_row_v_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = stbi__div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static stbi_uc* stbi__resample_row_h_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + stbi_uc *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = stbi__div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = stbi__div4(n+input[i-1]); + out[i*2+1] = stbi__div4(n+input[i+1]); + } + out[i*2+0] = stbi__div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define stbi__div16(x) ((stbi_uc) ((x) >> 4)) + +static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = stbi__div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static stbi_uc *stbi__resample_row_hv_2_simd(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i=0,t0,t1; + + if (w == 1) { + out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + // process groups of 8 pixels for as long as we can. + // note we can't handle the last pixel in a row in this loop + // because we need to handle the filter boundary conditions. + for (; i < ((w-1) & ~7); i += 8) { +#if defined(STBI_SSE2) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + __m128i zero = _mm_setzero_si128(); + __m128i farb = _mm_loadl_epi64((__m128i *) (in_far + i)); + __m128i nearb = _mm_loadl_epi64((__m128i *) (in_near + i)); + __m128i farw = _mm_unpacklo_epi8(farb, zero); + __m128i nearw = _mm_unpacklo_epi8(nearb, zero); + __m128i diff = _mm_sub_epi16(farw, nearw); + __m128i nears = _mm_slli_epi16(nearw, 2); + __m128i curr = _mm_add_epi16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + __m128i prv0 = _mm_slli_si128(curr, 2); + __m128i nxt0 = _mm_srli_si128(curr, 2); + __m128i prev = _mm_insert_epi16(prv0, t1, 0); + __m128i next = _mm_insert_epi16(nxt0, 3*in_near[i+8] + in_far[i+8], 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + __m128i bias = _mm_set1_epi16(8); + __m128i curs = _mm_slli_epi16(curr, 2); + __m128i prvd = _mm_sub_epi16(prev, curr); + __m128i nxtd = _mm_sub_epi16(next, curr); + __m128i curb = _mm_add_epi16(curs, bias); + __m128i even = _mm_add_epi16(prvd, curb); + __m128i odd = _mm_add_epi16(nxtd, curb); + + // interleave even and odd pixels, then undo scaling. + __m128i int0 = _mm_unpacklo_epi16(even, odd); + __m128i int1 = _mm_unpackhi_epi16(even, odd); + __m128i de0 = _mm_srli_epi16(int0, 4); + __m128i de1 = _mm_srli_epi16(int1, 4); + + // pack and write output + __m128i outv = _mm_packus_epi16(de0, de1); + _mm_storeu_si128((__m128i *) (out + i*2), outv); +#elif defined(STBI_NEON) + // load and perform the vertical filtering pass + // this uses 3*x + y = 4*x + (y - x) + uint8x8_t farb = vld1_u8(in_far + i); + uint8x8_t nearb = vld1_u8(in_near + i); + int16x8_t diff = vreinterpretq_s16_u16(vsubl_u8(farb, nearb)); + int16x8_t nears = vreinterpretq_s16_u16(vshll_n_u8(nearb, 2)); + int16x8_t curr = vaddq_s16(nears, diff); // current row + + // horizontal filter works the same based on shifted vers of current + // row. "prev" is current row shifted right by 1 pixel; we need to + // insert the previous pixel value (from t1). + // "next" is current row shifted left by 1 pixel, with first pixel + // of next block of 8 pixels added in. + int16x8_t prv0 = vextq_s16(curr, curr, 7); + int16x8_t nxt0 = vextq_s16(curr, curr, 1); + int16x8_t prev = vsetq_lane_s16(t1, prv0, 0); + int16x8_t next = vsetq_lane_s16(3*in_near[i+8] + in_far[i+8], nxt0, 7); + + // horizontal filter, polyphase implementation since it's convenient: + // even pixels = 3*cur + prev = cur*4 + (prev - cur) + // odd pixels = 3*cur + next = cur*4 + (next - cur) + // note the shared term. + int16x8_t curs = vshlq_n_s16(curr, 2); + int16x8_t prvd = vsubq_s16(prev, curr); + int16x8_t nxtd = vsubq_s16(next, curr); + int16x8_t even = vaddq_s16(curs, prvd); + int16x8_t odd = vaddq_s16(curs, nxtd); + + // undo scaling and round, then store with even/odd phases interleaved + uint8x8x2_t o; + o.val[0] = vqrshrun_n_s16(even, 4); + o.val[1] = vqrshrun_n_s16(odd, 4); + vst2_u8(out + i*2, o); +#endif + + // "previous" value for next iter + t1 = 3*in_near[i+7] + in_far[i+7]; + } + + t0 = t1; + t1 = 3*in_near[i] + in_far[i]; + out[i*2] = stbi__div16(3*t1 + t0 + 8); + + for (++i; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = stbi__div16(3*t0 + t1 + 8); + out[i*2 ] = stbi__div16(3*t1 + t0 + 8); + } + out[w*2-1] = stbi__div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} +#endif + +static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + STBI_NOTUSED(in_far); + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +// this is a reduced-precision calculation of YCbCr-to-RGB introduced +// to make sure the code produces the same results in both SIMD and scalar +#define stbi__float2fixed(x) (((int) ((x) * 4096.0f + 0.5f)) << 8) +static void stbi__YCbCr_to_RGB_row(stbi_uc *out, const stbi_uc *y, const stbi_uc *pcb, const stbi_uc *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + (cr*-stbi__float2fixed(0.71414f)) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} + +#if defined(STBI_SSE2) || defined(STBI_NEON) +static void stbi__YCbCr_to_RGB_simd(stbi_uc *out, stbi_uc const *y, stbi_uc const *pcb, stbi_uc const *pcr, int count, int step) +{ + int i = 0; + +#ifdef STBI_SSE2 + // step == 3 is pretty ugly on the final interleave, and i'm not convinced + // it's useful in practice (you wouldn't use it for textures, for example). + // so just accelerate step == 4 case. + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + __m128i signflip = _mm_set1_epi8(-0x80); + __m128i cr_const0 = _mm_set1_epi16( (short) ( 1.40200f*4096.0f+0.5f)); + __m128i cr_const1 = _mm_set1_epi16( - (short) ( 0.71414f*4096.0f+0.5f)); + __m128i cb_const0 = _mm_set1_epi16( - (short) ( 0.34414f*4096.0f+0.5f)); + __m128i cb_const1 = _mm_set1_epi16( (short) ( 1.77200f*4096.0f+0.5f)); + __m128i y_bias = _mm_set1_epi8((char) (unsigned char) 128); + __m128i xw = _mm_set1_epi16(255); // alpha channel + + for (; i+7 < count; i += 8) { + // load + __m128i y_bytes = _mm_loadl_epi64((__m128i *) (y+i)); + __m128i cr_bytes = _mm_loadl_epi64((__m128i *) (pcr+i)); + __m128i cb_bytes = _mm_loadl_epi64((__m128i *) (pcb+i)); + __m128i cr_biased = _mm_xor_si128(cr_bytes, signflip); // -128 + __m128i cb_biased = _mm_xor_si128(cb_bytes, signflip); // -128 + + // unpack to short (and left-shift cr, cb by 8) + __m128i yw = _mm_unpacklo_epi8(y_bias, y_bytes); + __m128i crw = _mm_unpacklo_epi8(_mm_setzero_si128(), cr_biased); + __m128i cbw = _mm_unpacklo_epi8(_mm_setzero_si128(), cb_biased); + + // color transform + __m128i yws = _mm_srli_epi16(yw, 4); + __m128i cr0 = _mm_mulhi_epi16(cr_const0, crw); + __m128i cb0 = _mm_mulhi_epi16(cb_const0, cbw); + __m128i cb1 = _mm_mulhi_epi16(cbw, cb_const1); + __m128i cr1 = _mm_mulhi_epi16(crw, cr_const1); + __m128i rws = _mm_add_epi16(cr0, yws); + __m128i gwt = _mm_add_epi16(cb0, yws); + __m128i bws = _mm_add_epi16(yws, cb1); + __m128i gws = _mm_add_epi16(gwt, cr1); + + // descale + __m128i rw = _mm_srai_epi16(rws, 4); + __m128i bw = _mm_srai_epi16(bws, 4); + __m128i gw = _mm_srai_epi16(gws, 4); + + // back to byte, set up for transpose + __m128i brb = _mm_packus_epi16(rw, bw); + __m128i gxb = _mm_packus_epi16(gw, xw); + + // transpose to interleave channels + __m128i t0 = _mm_unpacklo_epi8(brb, gxb); + __m128i t1 = _mm_unpackhi_epi8(brb, gxb); + __m128i o0 = _mm_unpacklo_epi16(t0, t1); + __m128i o1 = _mm_unpackhi_epi16(t0, t1); + + // store + _mm_storeu_si128((__m128i *) (out + 0), o0); + _mm_storeu_si128((__m128i *) (out + 16), o1); + out += 32; + } + } +#endif + +#ifdef STBI_NEON + // in this version, step=3 support would be easy to add. but is there demand? + if (step == 4) { + // this is a fairly straightforward implementation and not super-optimized. + uint8x8_t signflip = vdup_n_u8(0x80); + int16x8_t cr_const0 = vdupq_n_s16( (short) ( 1.40200f*4096.0f+0.5f)); + int16x8_t cr_const1 = vdupq_n_s16( - (short) ( 0.71414f*4096.0f+0.5f)); + int16x8_t cb_const0 = vdupq_n_s16( - (short) ( 0.34414f*4096.0f+0.5f)); + int16x8_t cb_const1 = vdupq_n_s16( (short) ( 1.77200f*4096.0f+0.5f)); + + for (; i+7 < count; i += 8) { + // load + uint8x8_t y_bytes = vld1_u8(y + i); + uint8x8_t cr_bytes = vld1_u8(pcr + i); + uint8x8_t cb_bytes = vld1_u8(pcb + i); + int8x8_t cr_biased = vreinterpret_s8_u8(vsub_u8(cr_bytes, signflip)); + int8x8_t cb_biased = vreinterpret_s8_u8(vsub_u8(cb_bytes, signflip)); + + // expand to s16 + int16x8_t yws = vreinterpretq_s16_u16(vshll_n_u8(y_bytes, 4)); + int16x8_t crw = vshll_n_s8(cr_biased, 7); + int16x8_t cbw = vshll_n_s8(cb_biased, 7); + + // color transform + int16x8_t cr0 = vqdmulhq_s16(crw, cr_const0); + int16x8_t cb0 = vqdmulhq_s16(cbw, cb_const0); + int16x8_t cr1 = vqdmulhq_s16(crw, cr_const1); + int16x8_t cb1 = vqdmulhq_s16(cbw, cb_const1); + int16x8_t rws = vaddq_s16(yws, cr0); + int16x8_t gws = vaddq_s16(vaddq_s16(yws, cb0), cr1); + int16x8_t bws = vaddq_s16(yws, cb1); + + // undo scaling, round, convert to byte + uint8x8x4_t o; + o.val[0] = vqrshrun_n_s16(rws, 4); + o.val[1] = vqrshrun_n_s16(gws, 4); + o.val[2] = vqrshrun_n_s16(bws, 4); + o.val[3] = vdup_n_u8(255); + + // store, interleaving r/g/b/a + vst4_u8(out, o); + out += 8*4; + } + } +#endif + + for (; i < count; ++i) { + int y_fixed = (y[i] << 20) + (1<<19); // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr* stbi__float2fixed(1.40200f); + g = y_fixed + cr*-stbi__float2fixed(0.71414f) + ((cb*-stbi__float2fixed(0.34414f)) & 0xffff0000); + b = y_fixed + cb* stbi__float2fixed(1.77200f); + r >>= 20; + g >>= 20; + b >>= 20; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (stbi_uc)r; + out[1] = (stbi_uc)g; + out[2] = (stbi_uc)b; + out[3] = 255; + out += step; + } +} +#endif + +// set up the kernels +static void stbi__setup_jpeg(stbi__jpeg *j) +{ + j->idct_block_kernel = stbi__idct_block; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_row; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2; + +#ifdef STBI_SSE2 + if (stbi__sse2_available()) { + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; + } +#endif + +#ifdef STBI_NEON + j->idct_block_kernel = stbi__idct_simd; + j->YCbCr_to_RGB_kernel = stbi__YCbCr_to_RGB_simd; + j->resample_row_hv_2_kernel = stbi__resample_row_hv_2_simd; +#endif +} + +// clean up the temporary component buffers +static void stbi__cleanup_jpeg(stbi__jpeg *j) +{ + stbi__free_jpeg_components(j, j->s->img_n, 0); +} + +typedef struct +{ + resample_row_func resample; + stbi_uc *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi__resample; + +// fast 0..255 * 0..255 => 0..255 rounded multiplication +static stbi_uc stbi__blinn_8x8(stbi_uc x, stbi_uc y) +{ + unsigned int t = x*y + 128; + return (stbi_uc) ((t + (t >>8)) >> 8); +} + +static stbi_uc *load_jpeg_image(stbi__jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n, is_rgb; + z->s->img_n = 0; // make stbi__cleanup_jpeg safe + + // validate req_comp + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + + // load a jpeg image from whichever source, but leave in YCbCr format + if (!stbi__decode_jpeg_image(z)) { stbi__cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s->img_n >= 3 ? 3 : 1; + + is_rgb = z->s->img_n == 3 && (z->rgb == 3 || (z->app14_color_transform == 0 && !z->jfif)); + + if (z->s->img_n == 3 && n < 3 && !is_rgb) + decode_n = 1; + else + decode_n = z->s->img_n; + + // nothing to do if no components requested; check this now to avoid + // accessing uninitialized coutput[0] later + if (decode_n <= 0) { stbi__cleanup_jpeg(z); return NULL; } + + // resample and color-convert + { + int k; + unsigned int i,j; + stbi_uc *output; + stbi_uc *coutput[4] = { NULL, NULL, NULL, NULL }; + + stbi__resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (stbi_uc *) stbi__malloc(z->s->img_x + 3); + if (!z->img_comp[k].linebuf) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s->img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = stbi__resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = stbi__resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = z->resample_row_hv_2_kernel; + else r->resample = stbi__resample_row_generic; + } + + // can't error after this so, this is safe + output = (stbi_uc *) stbi__malloc_mad3(n, z->s->img_x, z->s->img_y, 1); + if (!output) { stbi__cleanup_jpeg(z); return stbi__errpuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s->img_y; ++j) { + stbi_uc *out = output + n * z->s->img_x * j; + for (k=0; k < decode_n; ++k) { + stbi__resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + stbi_uc *y = coutput[0]; + if (z->s->img_n == 3) { + if (is_rgb) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = y[i]; + out[1] = coutput[1][i]; + out[2] = coutput[2][i]; + out[3] = 255; + out += n; + } + } else { + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else if (z->s->img_n == 4) { + if (z->app14_color_transform == 0) { // CMYK + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(coutput[0][i], m); + out[1] = stbi__blinn_8x8(coutput[1][i], m); + out[2] = stbi__blinn_8x8(coutput[2][i], m); + out[3] = 255; + out += n; + } + } else if (z->app14_color_transform == 2) { // YCCK + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + out[0] = stbi__blinn_8x8(255 - out[0], m); + out[1] = stbi__blinn_8x8(255 - out[1], m); + out[2] = stbi__blinn_8x8(255 - out[2], m); + out += n; + } + } else { // YCbCr + alpha? Ignore the fourth channel for now + z->YCbCr_to_RGB_kernel(out, y, coutput[1], coutput[2], z->s->img_x, n); + } + } else + for (i=0; i < z->s->img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + if (is_rgb) { + if (n == 1) + for (i=0; i < z->s->img_x; ++i) + *out++ = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + else { + for (i=0; i < z->s->img_x; ++i, out += 2) { + out[0] = stbi__compute_y(coutput[0][i], coutput[1][i], coutput[2][i]); + out[1] = 255; + } + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 0) { + for (i=0; i < z->s->img_x; ++i) { + stbi_uc m = coutput[3][i]; + stbi_uc r = stbi__blinn_8x8(coutput[0][i], m); + stbi_uc g = stbi__blinn_8x8(coutput[1][i], m); + stbi_uc b = stbi__blinn_8x8(coutput[2][i], m); + out[0] = stbi__compute_y(r, g, b); + out[1] = 255; + out += n; + } + } else if (z->s->img_n == 4 && z->app14_color_transform == 2) { + for (i=0; i < z->s->img_x; ++i) { + out[0] = stbi__blinn_8x8(255 - coutput[0][i], coutput[3][i]); + out[1] = 255; + out += n; + } + } else { + stbi_uc *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s->img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s->img_x; ++i) { *out++ = y[i]; *out++ = 255; } + } + } + } + stbi__cleanup_jpeg(z); + *out_x = z->s->img_x; + *out_y = z->s->img_y; + if (comp) *comp = z->s->img_n >= 3 ? 3 : 1; // report original components, not output + return output; + } +} + +static void *stbi__jpeg_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + unsigned char* result; + stbi__jpeg* j = (stbi__jpeg*) stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__errpuc("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + STBI_NOTUSED(ri); + j->s = s; + stbi__setup_jpeg(j); + result = load_jpeg_image(j, x,y,comp,req_comp); + STBI_FREE(j); + return result; +} + +static int stbi__jpeg_test(stbi__context *s) +{ + int r; + stbi__jpeg* j = (stbi__jpeg*)stbi__malloc(sizeof(stbi__jpeg)); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + stbi__setup_jpeg(j); + r = stbi__decode_jpeg_header(j, STBI__SCAN_type); + stbi__rewind(s); + STBI_FREE(j); + return r; +} + +static int stbi__jpeg_info_raw(stbi__jpeg *j, int *x, int *y, int *comp) +{ + if (!stbi__decode_jpeg_header(j, STBI__SCAN_header)) { + stbi__rewind( j->s ); + return 0; + } + if (x) *x = j->s->img_x; + if (y) *y = j->s->img_y; + if (comp) *comp = j->s->img_n >= 3 ? 3 : 1; + return 1; +} + +static int stbi__jpeg_info(stbi__context *s, int *x, int *y, int *comp) +{ + int result; + stbi__jpeg* j = (stbi__jpeg*) (stbi__malloc(sizeof(stbi__jpeg))); + if (!j) return stbi__err("outofmem", "Out of memory"); + memset(j, 0, sizeof(stbi__jpeg)); + j->s = s; + result = stbi__jpeg_info_raw(j, x, y, comp); + STBI_FREE(j); + return result; +} +#endif + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +#ifndef STBI_NO_ZLIB + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define STBI__ZFAST_BITS 9 // accelerate all cases in default tables +#define STBI__ZFAST_MASK ((1 << STBI__ZFAST_BITS) - 1) +#define STBI__ZNSYMS 288 // number of symbols in literal/length alphabet + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + stbi__uint16 fast[1 << STBI__ZFAST_BITS]; + stbi__uint16 firstcode[16]; + int maxcode[17]; + stbi__uint16 firstsymbol[16]; + stbi_uc size[STBI__ZNSYMS]; + stbi__uint16 value[STBI__ZNSYMS]; +} stbi__zhuffman; + +stbi_inline static int stbi__bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +stbi_inline static int stbi__bit_reverse(int v, int bits) +{ + STBI_ASSERT(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return stbi__bitreverse16(v) >> (16-bits); +} + +static int stbi__zbuild_huffman(stbi__zhuffman *z, const stbi_uc *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 0, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + if (sizes[i] > (1 << i)) + return stbi__err("bad sizes", "Corrupt PNG"); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (stbi__uint16) code; + z->firstsymbol[i] = (stbi__uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return stbi__err("bad codelengths","Corrupt PNG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + stbi__uint16 fastv = (stbi__uint16) ((s << 9) | i); + z->size [c] = (stbi_uc ) s; + z->value[c] = (stbi__uint16) i; + if (s <= STBI__ZFAST_BITS) { + int j = stbi__bit_reverse(next_code[s],s); + while (j < (1 << STBI__ZFAST_BITS)) { + z->fast[j] = fastv; + j += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + stbi_uc *zbuffer, *zbuffer_end; + int num_bits; + int hit_zeof_once; + stbi__uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + stbi__zhuffman z_length, z_distance; +} stbi__zbuf; + +stbi_inline static int stbi__zeof(stbi__zbuf *z) +{ + return (z->zbuffer >= z->zbuffer_end); +} + +stbi_inline static stbi_uc stbi__zget8(stbi__zbuf *z) +{ + return stbi__zeof(z) ? 0 : *z->zbuffer++; +} + +static void stbi__fill_bits(stbi__zbuf *z) +{ + do { + if (z->code_buffer >= (1U << z->num_bits)) { + z->zbuffer = z->zbuffer_end; /* treat this as EOF so we fail. */ + return; + } + z->code_buffer |= (unsigned int) stbi__zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +stbi_inline static unsigned int stbi__zreceive(stbi__zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) stbi__fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +static int stbi__zhuffman_decode_slowpath(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s,k; + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = stbi__bit_reverse(a->code_buffer, 16); + for (s=STBI__ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s >= 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + if (b >= STBI__ZNSYMS) return -1; // some data was corrupt somewhere! + if (z->size[b] != s) return -1; // was originally an assert, but report failure instead. + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +stbi_inline static int stbi__zhuffman_decode(stbi__zbuf *a, stbi__zhuffman *z) +{ + int b,s; + if (a->num_bits < 16) { + if (stbi__zeof(a)) { + if (!a->hit_zeof_once) { + // This is the first time we hit eof, insert 16 extra padding btis + // to allow us to keep going; if we actually consume any of them + // though, that is invalid data. This is caught later. + a->hit_zeof_once = 1; + a->num_bits += 16; // add 16 implicit zero bits + } else { + // We already inserted our extra 16 padding bits and are again + // out, this stream is actually prematurely terminated. + return -1; + } + } else { + stbi__fill_bits(a); + } + } + b = z->fast[a->code_buffer & STBI__ZFAST_MASK]; + if (b) { + s = b >> 9; + a->code_buffer >>= s; + a->num_bits -= s; + return b & 511; + } + return stbi__zhuffman_decode_slowpath(a, z); +} + +static int stbi__zexpand(stbi__zbuf *z, char *zout, int n) // need to make room for n bytes +{ + char *q; + unsigned int cur, limit, old_limit; + z->zout = zout; + if (!z->z_expandable) return stbi__err("output buffer limit","Corrupt PNG"); + cur = (unsigned int) (z->zout - z->zout_start); + limit = old_limit = (unsigned) (z->zout_end - z->zout_start); + if (UINT_MAX - cur < (unsigned) n) return stbi__err("outofmem", "Out of memory"); + while (cur + n > limit) { + if(limit > UINT_MAX / 2) return stbi__err("outofmem", "Out of memory"); + limit *= 2; + } + q = (char *) STBI_REALLOC_SIZED(z->zout_start, old_limit, limit); + STBI_NOTUSED(old_limit); + if (q == NULL) return stbi__err("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static const int stbi__zlength_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static const int stbi__zlength_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static const int stbi__zdist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static const int stbi__zdist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int stbi__parse_huffman_block(stbi__zbuf *a) +{ + char *zout = a->zout; + for(;;) { + int z = stbi__zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return stbi__err("bad huffman code","Corrupt PNG"); // error in huffman codes + if (zout >= a->zout_end) { + if (!stbi__zexpand(a, zout, 1)) return 0; + zout = a->zout; + } + *zout++ = (char) z; + } else { + stbi_uc *p; + int len,dist; + if (z == 256) { + a->zout = zout; + if (a->hit_zeof_once && a->num_bits < 16) { + // The first time we hit zeof, we inserted 16 extra zero bits into our bit + // buffer so the decoder can just do its speculative decoding. But if we + // actually consumed any of those bits (which is the case when num_bits < 16), + // the stream actually read past the end so it is malformed. + return stbi__err("unexpected end","Corrupt PNG"); + } + return 1; + } + if (z >= 286) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, length codes 286 and 287 must not appear in compressed data + z -= 257; + len = stbi__zlength_base[z]; + if (stbi__zlength_extra[z]) len += stbi__zreceive(a, stbi__zlength_extra[z]); + z = stbi__zhuffman_decode(a, &a->z_distance); + if (z < 0 || z >= 30) return stbi__err("bad huffman code","Corrupt PNG"); // per DEFLATE, distance codes 30 and 31 must not appear in compressed data + dist = stbi__zdist_base[z]; + if (stbi__zdist_extra[z]) dist += stbi__zreceive(a, stbi__zdist_extra[z]); + if (zout - a->zout_start < dist) return stbi__err("bad dist","Corrupt PNG"); + if (len > a->zout_end - zout) { + if (!stbi__zexpand(a, zout, len)) return 0; + zout = a->zout; + } + p = (stbi_uc *) (zout - dist); + if (dist == 1) { // run of one byte; common in images. + stbi_uc v = *p; + if (len) { do *zout++ = v; while (--len); } + } else { + if (len) { do *zout++ = *p++; while (--len); } + } + } + } +} + +static int stbi__compute_huffman_codes(stbi__zbuf *a) +{ + static const stbi_uc length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + stbi__zhuffman z_codelength; + stbi_uc lencodes[286+32+137];//padding for maximum single op + stbi_uc codelength_sizes[19]; + int i,n; + + int hlit = stbi__zreceive(a,5) + 257; + int hdist = stbi__zreceive(a,5) + 1; + int hclen = stbi__zreceive(a,4) + 4; + int ntot = hlit + hdist; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = stbi__zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (stbi_uc) s; + } + if (!stbi__zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < ntot) { + int c = stbi__zhuffman_decode(a, &z_codelength); + if (c < 0 || c >= 19) return stbi__err("bad codelengths", "Corrupt PNG"); + if (c < 16) + lencodes[n++] = (stbi_uc) c; + else { + stbi_uc fill = 0; + if (c == 16) { + c = stbi__zreceive(a,2)+3; + if (n == 0) return stbi__err("bad codelengths", "Corrupt PNG"); + fill = lencodes[n-1]; + } else if (c == 17) { + c = stbi__zreceive(a,3)+3; + } else if (c == 18) { + c = stbi__zreceive(a,7)+11; + } else { + return stbi__err("bad codelengths", "Corrupt PNG"); + } + if (ntot - n < c) return stbi__err("bad codelengths", "Corrupt PNG"); + memset(lencodes+n, fill, c); + n += c; + } + } + if (n != ntot) return stbi__err("bad codelengths","Corrupt PNG"); + if (!stbi__zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int stbi__parse_uncompressed_block(stbi__zbuf *a) +{ + stbi_uc header[4]; + int len,nlen,k; + if (a->num_bits & 7) + stbi__zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (stbi_uc) (a->code_buffer & 255); // suppress MSVC run-time check + a->code_buffer >>= 8; + a->num_bits -= 8; + } + if (a->num_bits < 0) return stbi__err("zlib corrupt","Corrupt PNG"); + // now fill header the normal way + while (k < 4) + header[k++] = stbi__zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return stbi__err("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return stbi__err("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!stbi__zexpand(a, a->zout, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int stbi__parse_zlib_header(stbi__zbuf *a) +{ + int cmf = stbi__zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = stbi__zget8(a); + if (stbi__zeof(a)) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if ((cmf*256+flg) % 31 != 0) return stbi__err("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return stbi__err("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return stbi__err("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +static const stbi_uc stbi__zdefault_length[STBI__ZNSYMS] = +{ + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, + 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8 +}; +static const stbi_uc stbi__zdefault_distance[32] = +{ + 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5 +}; +/* +Init algorithm: +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) stbi__zdefault_length[i] = 8; + for ( ; i <= 255; ++i) stbi__zdefault_length[i] = 9; + for ( ; i <= 279; ++i) stbi__zdefault_length[i] = 7; + for ( ; i <= 287; ++i) stbi__zdefault_length[i] = 8; + + for (i=0; i <= 31; ++i) stbi__zdefault_distance[i] = 5; +} +*/ + +static int stbi__parse_zlib(stbi__zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!stbi__parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + a->hit_zeof_once = 0; + do { + final = stbi__zreceive(a,1); + type = stbi__zreceive(a,2); + if (type == 0) { + if (!stbi__parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!stbi__zbuild_huffman(&a->z_length , stbi__zdefault_length , STBI__ZNSYMS)) return 0; + if (!stbi__zbuild_huffman(&a->z_distance, stbi__zdefault_distance, 32)) return 0; + } else { + if (!stbi__compute_huffman_codes(a)) return 0; + } + if (!stbi__parse_huffman_block(a)) return 0; + } + } while (!final); + return 1; +} + +static int stbi__do_zlib(stbi__zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return stbi__parse_zlib(a, parse_header); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +STBIDEF char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer + len; + if (stbi__do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +STBIDEF char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + stbi__zbuf a; + char *p = (char *) stbi__malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (stbi_uc *) buffer; + a.zbuffer_end = (stbi_uc *) buffer+len; + if (stbi__do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + STBI_FREE(a.zout_start); + return NULL; + } +} + +STBIDEF int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + stbi__zbuf a; + a.zbuffer = (stbi_uc *) ibuffer; + a.zbuffer_end = (stbi_uc *) ibuffer + ilen; + if (stbi__do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} +#endif + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + +#ifndef STBI_NO_PNG +typedef struct +{ + stbi__uint32 length; + stbi__uint32 type; +} stbi__pngchunk; + +static stbi__pngchunk stbi__get_chunk_header(stbi__context *s) +{ + stbi__pngchunk c; + c.length = stbi__get32be(s); + c.type = stbi__get32be(s); + return c; +} + +static int stbi__check_png_header(stbi__context *s) +{ + static const stbi_uc png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (stbi__get8(s) != png_sig[i]) return stbi__err("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi__context *s; + stbi_uc *idata, *expanded, *out; + int depth; +} stbi__png; + + +enum { + STBI__F_none=0, + STBI__F_sub=1, + STBI__F_up=2, + STBI__F_avg=3, + STBI__F_paeth=4, + // synthetic filter used for first scanline to avoid needing a dummy row of 0s + STBI__F_avg_first +}; + +static stbi_uc first_row_filter[5] = +{ + STBI__F_none, + STBI__F_sub, + STBI__F_none, + STBI__F_avg_first, + STBI__F_sub // Paeth with b=c=0 turns out to be equivalent to sub +}; + +static int stbi__paeth(int a, int b, int c) +{ + // This formulation looks very different from the reference in the PNG spec, but is + // actually equivalent and has favorable data dependencies and admits straightforward + // generation of branch-free code, which helps performance significantly. + int thresh = c*3 - (a + b); + int lo = a < b ? a : b; + int hi = a < b ? b : a; + int t0 = (hi <= thresh) ? lo : c; + int t1 = (thresh <= lo) ? hi : t0; + return t1; +} + +static const stbi_uc stbi__depth_scale_table[9] = { 0, 0xff, 0x55, 0, 0x11, 0,0,0, 0x01 }; + +// adds an extra all-255 alpha channel +// dest == src is legal +// img_n must be 1 or 3 +static void stbi__create_png_alpha_expand8(stbi_uc *dest, stbi_uc *src, stbi__uint32 x, int img_n) +{ + int i; + // must process data backwards since we allow dest==src + if (img_n == 1) { + for (i=x-1; i >= 0; --i) { + dest[i*2+1] = 255; + dest[i*2+0] = src[i]; + } + } else { + STBI_ASSERT(img_n == 3); + for (i=x-1; i >= 0; --i) { + dest[i*4+3] = 255; + dest[i*4+2] = src[i*3+2]; + dest[i*4+1] = src[i*3+1]; + dest[i*4+0] = src[i*3+0]; + } + } +} + +// create the png data from post-deflated data +static int stbi__create_png_image_raw(stbi__png *a, stbi_uc *raw, stbi__uint32 raw_len, int out_n, stbi__uint32 x, stbi__uint32 y, int depth, int color) +{ + int bytes = (depth == 16 ? 2 : 1); + stbi__context *s = a->s; + stbi__uint32 i,j,stride = x*out_n*bytes; + stbi__uint32 img_len, img_width_bytes; + stbi_uc *filter_buf; + int all_ok = 1; + int k; + int img_n = s->img_n; // copy it into a local for later + + int output_bytes = out_n*bytes; + int filter_bytes = img_n*bytes; + int width = x; + + STBI_ASSERT(out_n == s->img_n || out_n == s->img_n+1); + a->out = (stbi_uc *) stbi__malloc_mad3(x, y, output_bytes, 0); // extra bytes to write off the end into + if (!a->out) return stbi__err("outofmem", "Out of memory"); + + // note: error exits here don't need to clean up a->out individually, + // stbi__do_png always does on error. + if (!stbi__mad3sizes_valid(img_n, x, depth, 7)) return stbi__err("too large", "Corrupt PNG"); + img_width_bytes = (((img_n * x * depth) + 7) >> 3); + if (!stbi__mad2sizes_valid(img_width_bytes, y, img_width_bytes)) return stbi__err("too large", "Corrupt PNG"); + img_len = (img_width_bytes + 1) * y; + + // we used to check for exact match between raw_len and img_len on non-interlaced PNGs, + // but issue #276 reported a PNG in the wild that had extra data at the end (all zeros), + // so just check for raw_len < img_len always. + if (raw_len < img_len) return stbi__err("not enough pixels","Corrupt PNG"); + + // Allocate two scan lines worth of filter workspace buffer. + filter_buf = (stbi_uc *) stbi__malloc_mad2(img_width_bytes, 2, 0); + if (!filter_buf) return stbi__err("outofmem", "Out of memory"); + + // Filtering for low-bit-depth images + if (depth < 8) { + filter_bytes = 1; + width = img_width_bytes; + } + + for (j=0; j < y; ++j) { + // cur/prior filter buffers alternate + stbi_uc *cur = filter_buf + (j & 1)*img_width_bytes; + stbi_uc *prior = filter_buf + (~j & 1)*img_width_bytes; + stbi_uc *dest = a->out + stride*j; + int nk = width * filter_bytes; + int filter = *raw++; + + // check filter type + if (filter > 4) { + all_ok = stbi__err("invalid filter","Corrupt PNG"); + break; + } + + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + + // perform actual filtering + switch (filter) { + case STBI__F_none: + memcpy(cur, raw, nk); + break; + case STBI__F_sub: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + cur[k-filter_bytes]); + break; + case STBI__F_up: + for (k = 0; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); + break; + case STBI__F_avg: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (prior[k]>>1)); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + ((prior[k] + cur[k-filter_bytes])>>1)); + break; + case STBI__F_paeth: + for (k = 0; k < filter_bytes; ++k) + cur[k] = STBI__BYTECAST(raw[k] + prior[k]); // prior[k] == stbi__paeth(0,prior[k],0) + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + stbi__paeth(cur[k-filter_bytes], prior[k], prior[k-filter_bytes])); + break; + case STBI__F_avg_first: + memcpy(cur, raw, filter_bytes); + for (k = filter_bytes; k < nk; ++k) + cur[k] = STBI__BYTECAST(raw[k] + (cur[k-filter_bytes] >> 1)); + break; + } + + raw += nk; + + // expand decoded bits in cur to dest, also adding an extra alpha channel if desired + if (depth < 8) { + stbi_uc scale = (color == 0) ? stbi__depth_scale_table[depth] : 1; // scale grayscale values to 0..255 range + stbi_uc *in = cur; + stbi_uc *out = dest; + stbi_uc inb = 0; + stbi__uint32 nsmp = x*img_n; + + // expand bits to bytes first + if (depth == 4) { + for (i=0; i < nsmp; ++i) { + if ((i & 1) == 0) inb = *in++; + *out++ = scale * (inb >> 4); + inb <<= 4; + } + } else if (depth == 2) { + for (i=0; i < nsmp; ++i) { + if ((i & 3) == 0) inb = *in++; + *out++ = scale * (inb >> 6); + inb <<= 2; + } + } else { + STBI_ASSERT(depth == 1); + for (i=0; i < nsmp; ++i) { + if ((i & 7) == 0) inb = *in++; + *out++ = scale * (inb >> 7); + inb <<= 1; + } + } + + // insert alpha=255 values if desired + if (img_n != out_n) + stbi__create_png_alpha_expand8(dest, dest, x, img_n); + } else if (depth == 8) { + if (img_n == out_n) + memcpy(dest, cur, x*img_n); + else + stbi__create_png_alpha_expand8(dest, cur, x, img_n); + } else if (depth == 16) { + // convert the image data from big-endian to platform-native + stbi__uint16 *dest16 = (stbi__uint16*)dest; + stbi__uint32 nsmp = x*img_n; + + if (img_n == out_n) { + for (i = 0; i < nsmp; ++i, ++dest16, cur += 2) + *dest16 = (cur[0] << 8) | cur[1]; + } else { + STBI_ASSERT(img_n+1 == out_n); + if (img_n == 1) { + for (i = 0; i < x; ++i, dest16 += 2, cur += 2) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = 0xffff; + } + } else { + STBI_ASSERT(img_n == 3); + for (i = 0; i < x; ++i, dest16 += 4, cur += 6) { + dest16[0] = (cur[0] << 8) | cur[1]; + dest16[1] = (cur[2] << 8) | cur[3]; + dest16[2] = (cur[4] << 8) | cur[5]; + dest16[3] = 0xffff; + } + } + } + } + } + + STBI_FREE(filter_buf); + if (!all_ok) return 0; + + return 1; +} + +static int stbi__create_png_image(stbi__png *a, stbi_uc *image_data, stbi__uint32 image_data_len, int out_n, int depth, int color, int interlaced) +{ + int bytes = (depth == 16 ? 2 : 1); + int out_bytes = out_n * bytes; + stbi_uc *final; + int p; + if (!interlaced) + return stbi__create_png_image_raw(a, image_data, image_data_len, out_n, a->s->img_x, a->s->img_y, depth, color); + + // de-interlacing + final = (stbi_uc *) stbi__malloc_mad3(a->s->img_x, a->s->img_y, out_bytes, 0); + if (!final) return stbi__err("outofmem", "Out of memory"); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s->img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s->img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + stbi__uint32 img_len = ((((a->s->img_n * x * depth) + 7) >> 3) + 1) * y; + if (!stbi__create_png_image_raw(a, image_data, image_data_len, out_n, x, y, depth, color)) { + STBI_FREE(final); + return 0; + } + for (j=0; j < y; ++j) { + for (i=0; i < x; ++i) { + int out_y = j*yspc[p]+yorig[p]; + int out_x = i*xspc[p]+xorig[p]; + memcpy(final + out_y*a->s->img_x*out_bytes + out_x*out_bytes, + a->out + (j*x+i)*out_bytes, out_bytes); + } + } + STBI_FREE(a->out); + image_data += img_len; + image_data_len -= img_len; + } + } + a->out = final; + + return 1; +} + +static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi__uint16 *p = (stbi__uint16*) z->out; + + // compute color-based transparency, assuming we've + // already got 65535 as the alpha value in the output + STBI_ASSERT(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i = 0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 65535); + p += 2; + } + } else { + for (i = 0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int stbi__expand_png_palette(stbi__png *a, stbi_uc *palette, int len, int pal_img_n) +{ + stbi__uint32 i, pixel_count = a->s->img_x * a->s->img_y; + stbi_uc *p, *temp_out, *orig = a->out; + + p = (stbi_uc *) stbi__malloc_mad2(pixel_count, pal_img_n, 0); + if (p == NULL) return stbi__err("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + STBI_FREE(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi__unpremultiply_on_load_global = 0; +static int stbi__de_iphone_flag_global = 0; + +STBIDEF void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_global = flag_true_if_should_unpremultiply; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_global = flag_true_if_should_convert; +} + +#ifndef STBI_THREAD_LOCAL +#define stbi__unpremultiply_on_load stbi__unpremultiply_on_load_global +#define stbi__de_iphone_flag stbi__de_iphone_flag_global +#else +static STBI_THREAD_LOCAL int stbi__unpremultiply_on_load_local, stbi__unpremultiply_on_load_set; +static STBI_THREAD_LOCAL int stbi__de_iphone_flag_local, stbi__de_iphone_flag_set; + +STBIDEF void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply) +{ + stbi__unpremultiply_on_load_local = flag_true_if_should_unpremultiply; + stbi__unpremultiply_on_load_set = 1; +} + +STBIDEF void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert) +{ + stbi__de_iphone_flag_local = flag_true_if_should_convert; + stbi__de_iphone_flag_set = 1; +} + +#define stbi__unpremultiply_on_load (stbi__unpremultiply_on_load_set \ + ? stbi__unpremultiply_on_load_local \ + : stbi__unpremultiply_on_load_global) +#define stbi__de_iphone_flag (stbi__de_iphone_flag_set \ + ? stbi__de_iphone_flag_local \ + : stbi__de_iphone_flag_global) +#endif // STBI_THREAD_LOCAL + +static void stbi__de_iphone(stbi__png *z) +{ + stbi__context *s = z->s; + stbi__uint32 i, pixel_count = s->img_x * s->img_y; + stbi_uc *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + STBI_ASSERT(s->img_out_n == 4); + if (stbi__unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + stbi_uc a = p[3]; + stbi_uc t = p[0]; + if (a) { + stbi_uc half = a / 2; + p[0] = (p[2] * 255 + half) / a; + p[1] = (p[1] * 255 + half) / a; + p[2] = ( t * 255 + half) / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + stbi_uc t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +#define STBI__PNG_TYPE(a,b,c,d) (((unsigned) (a) << 24) + ((unsigned) (b) << 16) + ((unsigned) (c) << 8) + (unsigned) (d)) + +static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) +{ + stbi_uc palette[1024], pal_img_n=0; + stbi_uc has_trans=0, tc[3]={0}; + stbi__uint16 tc16[3]; + stbi__uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, color=0, is_iphone=0; + stbi__context *s = z->s; + + z->expanded = NULL; + z->idata = NULL; + z->out = NULL; + + if (!stbi__check_png_header(s)) return 0; + + if (scan == STBI__SCAN_type) return 1; + + for (;;) { + stbi__pngchunk c = stbi__get_chunk_header(s); + switch (c.type) { + case STBI__PNG_TYPE('C','g','B','I'): + is_iphone = 1; + stbi__skip(s, c.length); + break; + case STBI__PNG_TYPE('I','H','D','R'): { + int comp,filter; + if (!first) return stbi__err("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return stbi__err("bad IHDR len","Corrupt PNG"); + s->img_x = stbi__get32be(s); + s->img_y = stbi__get32be(s); + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + z->depth = stbi__get8(s); if (z->depth != 1 && z->depth != 2 && z->depth != 4 && z->depth != 8 && z->depth != 16) return stbi__err("1/2/4/8/16-bit only","PNG not supported: 1/2/4/8/16-bit only"); + color = stbi__get8(s); if (color > 6) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3 && z->depth == 16) return stbi__err("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return stbi__err("bad ctype","Corrupt PNG"); + comp = stbi__get8(s); if (comp) return stbi__err("bad comp method","Corrupt PNG"); + filter= stbi__get8(s); if (filter) return stbi__err("bad filter method","Corrupt PNG"); + interlace = stbi__get8(s); if (interlace>1) return stbi__err("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return stbi__err("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return stbi__err("too large", "Image too large to decode"); + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return stbi__err("too large","Corrupt PNG"); + } + // even with SCAN_header, have to scan to see if we have a tRNS + break; + } + + case STBI__PNG_TYPE('P','L','T','E'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return stbi__err("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return stbi__err("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = stbi__get8(s); + palette[i*4+1] = stbi__get8(s); + palette[i*4+2] = stbi__get8(s); + palette[i*4+3] = 255; + } + break; + } + + case STBI__PNG_TYPE('t','R','N','S'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (z->idata) return stbi__err("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == STBI__SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return stbi__err("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return stbi__err("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = stbi__get8(s); + } else { + if (!(s->img_n & 1)) return stbi__err("tRNS with alpha","Corrupt PNG"); + if (c.length != (stbi__uint32) s->img_n*2) return stbi__err("bad tRNS len","Corrupt PNG"); + has_trans = 1; + // non-paletted with tRNS = constant alpha. if header-scanning, we can stop now. + if (scan == STBI__SCAN_header) { ++s->img_n; return 1; } + if (z->depth == 16) { + for (k = 0; k < s->img_n && k < 3; ++k) // extra loop test to suppress false GCC warning + tc16[k] = (stbi__uint16)stbi__get16be(s); // copy the values as-is + } else { + for (k = 0; k < s->img_n && k < 3; ++k) + tc[k] = (stbi_uc)(stbi__get16be(s) & 255) * stbi__depth_scale_table[z->depth]; // non 8-bit images will be larger + } + } + break; + } + + case STBI__PNG_TYPE('I','D','A','T'): { + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return stbi__err("no PLTE","Corrupt PNG"); + if (scan == STBI__SCAN_header) { + // header scan definitely stops at first IDAT + if (pal_img_n) + s->img_n = pal_img_n; + return 1; + } + if (c.length > (1u << 30)) return stbi__err("IDAT size limit", "IDAT section larger than 2^30 bytes"); + if ((int)(ioff + c.length) < (int)ioff) return 0; + if (ioff + c.length > idata_limit) { + stbi__uint32 idata_limit_old = idata_limit; + stbi_uc *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + STBI_NOTUSED(idata_limit_old); + p = (stbi_uc *) STBI_REALLOC_SIZED(z->idata, idata_limit_old, idata_limit); if (p == NULL) return stbi__err("outofmem", "Out of memory"); + z->idata = p; + } + if (!stbi__getn(s, z->idata+ioff,c.length)) return stbi__err("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case STBI__PNG_TYPE('I','E','N','D'): { + stbi__uint32 raw_len, bpl; + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if (scan != STBI__SCAN_load) return 1; + if (z->idata == NULL) return stbi__err("no IDAT","Corrupt PNG"); + // initial guess for decoded data size to avoid unnecessary reallocs + bpl = (s->img_x * z->depth + 7) / 8; // bytes per line, per component + raw_len = bpl * s->img_y * s->img_n /* pixels */ + s->img_y /* filter mode per row */; + z->expanded = (stbi_uc *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, raw_len, (int *) &raw_len, !is_iphone); + if (z->expanded == NULL) return 0; // zlib should set error + STBI_FREE(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!stbi__create_png_image(z, z->expanded, raw_len, s->img_out_n, z->depth, color, interlace)) return 0; + if (has_trans) { + if (z->depth == 16) { + if (!stbi__compute_transparency16(z, tc16, s->img_out_n)) return 0; + } else { + if (!stbi__compute_transparency(z, tc, s->img_out_n)) return 0; + } + } + if (is_iphone && stbi__de_iphone_flag && s->img_out_n > 2) + stbi__de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!stbi__expand_png_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } else if (has_trans) { + // non-paletted image with tRNS -> source image has (constant) alpha + ++s->img_n; + } + STBI_FREE(z->expanded); z->expanded = NULL; + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + return 1; + } + + default: + // if critical, fail + if (first) return stbi__err("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX PNG chunk not known"; + invalid_chunk[0] = STBI__BYTECAST(c.type >> 24); + invalid_chunk[1] = STBI__BYTECAST(c.type >> 16); + invalid_chunk[2] = STBI__BYTECAST(c.type >> 8); + invalid_chunk[3] = STBI__BYTECAST(c.type >> 0); + #endif + return stbi__err(invalid_chunk, "PNG not supported: unknown PNG chunk type"); + } + stbi__skip(s, c.length); + break; + } + // end of PNG chunk, read and skip CRC + stbi__get32be(s); + } +} + +static void *stbi__do_png(stbi__png *p, int *x, int *y, int *n, int req_comp, stbi__result_info *ri) +{ + void *result=NULL; + if (req_comp < 0 || req_comp > 4) return stbi__errpuc("bad req_comp", "Internal error"); + if (stbi__parse_png_file(p, STBI__SCAN_load, req_comp)) { + if (p->depth <= 8) + ri->bits_per_channel = 8; + else if (p->depth == 16) + ri->bits_per_channel = 16; + else + return stbi__errpuc("bad bits_per_channel", "PNG not supported: unsupported color depth"); + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s->img_out_n) { + if (ri->bits_per_channel == 8) + result = stbi__convert_format((unsigned char *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + else + result = stbi__convert_format16((stbi__uint16 *) result, p->s->img_out_n, req_comp, p->s->img_x, p->s->img_y); + p->s->img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s->img_x; + *y = p->s->img_y; + if (n) *n = p->s->img_n; + } + STBI_FREE(p->out); p->out = NULL; + STBI_FREE(p->expanded); p->expanded = NULL; + STBI_FREE(p->idata); p->idata = NULL; + + return result; +} + +static void *stbi__png_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi__png p; + p.s = s; + return stbi__do_png(&p, x,y,comp,req_comp, ri); +} + +static int stbi__png_test(stbi__context *s) +{ + int r; + r = stbi__check_png_header(s); + stbi__rewind(s); + return r; +} + +static int stbi__png_info_raw(stbi__png *p, int *x, int *y, int *comp) +{ + if (!stbi__parse_png_file(p, STBI__SCAN_header, 0)) { + stbi__rewind( p->s ); + return 0; + } + if (x) *x = p->s->img_x; + if (y) *y = p->s->img_y; + if (comp) *comp = p->s->img_n; + return 1; +} + +static int stbi__png_info(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__png p; + p.s = s; + return stbi__png_info_raw(&p, x, y, comp); +} + +static int stbi__png_is16(stbi__context *s) +{ + stbi__png p; + p.s = s; + if (!stbi__png_info_raw(&p, NULL, NULL, NULL)) + return 0; + if (p.depth != 16) { + stbi__rewind(p.s); + return 0; + } + return 1; +} +#endif + +// Microsoft/Windows BMP image + +#ifndef STBI_NO_BMP +static int stbi__bmp_test_raw(stbi__context *s) +{ + int r; + int sz; + if (stbi__get8(s) != 'B') return 0; + if (stbi__get8(s) != 'M') return 0; + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + stbi__get32le(s); // discard data offset + sz = stbi__get32le(s); + r = (sz == 12 || sz == 40 || sz == 56 || sz == 108 || sz == 124); + return r; +} + +static int stbi__bmp_test(stbi__context *s) +{ + int r = stbi__bmp_test_raw(s); + stbi__rewind(s); + return r; +} + + +// returns 0..31 for the highest set bit +static int stbi__high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) { n += 16; z >>= 16; } + if (z >= 0x00100) { n += 8; z >>= 8; } + if (z >= 0x00010) { n += 4; z >>= 4; } + if (z >= 0x00004) { n += 2; z >>= 2; } + if (z >= 0x00002) { n += 1;/* >>= 1;*/ } + return n; +} + +static int stbi__bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +// extract an arbitrarily-aligned N-bit value (N=bits) +// from v, and then make it 8-bits long and fractionally +// extend it to full full range. +static int stbi__shiftsigned(unsigned int v, int shift, int bits) +{ + static unsigned int mul_table[9] = { + 0, + 0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/, + 0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/, + }; + static unsigned int shift_table[9] = { + 0, 0,0,1,0,2,4,6,0, + }; + if (shift < 0) + v <<= -shift; + else + v >>= shift; + STBI_ASSERT(v < 256); + v >>= (8-bits); + STBI_ASSERT(bits >= 0 && bits <= 8); + return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits]; +} + +typedef struct +{ + int bpp, offset, hsz; + unsigned int mr,mg,mb,ma, all_a; + int extra_read; +} stbi__bmp_data; + +static int stbi__bmp_set_mask_defaults(stbi__bmp_data *info, int compress) +{ + // BI_BITFIELDS specifies masks explicitly, don't override + if (compress == 3) + return 1; + + if (compress == 0) { + if (info->bpp == 16) { + info->mr = 31u << 10; + info->mg = 31u << 5; + info->mb = 31u << 0; + } else if (info->bpp == 32) { + info->mr = 0xffu << 16; + info->mg = 0xffu << 8; + info->mb = 0xffu << 0; + info->ma = 0xffu << 24; + info->all_a = 0; // if all_a is 0 at end, then we loaded alpha channel but it was all 0 + } else { + // otherwise, use defaults, which is all-0 + info->mr = info->mg = info->mb = info->ma = 0; + } + return 1; + } + return 0; // error +} + +static void *stbi__bmp_parse_header(stbi__context *s, stbi__bmp_data *info) +{ + int hsz; + if (stbi__get8(s) != 'B' || stbi__get8(s) != 'M') return stbi__errpuc("not BMP", "Corrupt BMP"); + stbi__get32le(s); // discard filesize + stbi__get16le(s); // discard reserved + stbi__get16le(s); // discard reserved + info->offset = stbi__get32le(s); + info->hsz = hsz = stbi__get32le(s); + info->mr = info->mg = info->mb = info->ma = 0; + info->extra_read = 14; + + if (info->offset < 0) return stbi__errpuc("bad BMP", "bad BMP"); + + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108 && hsz != 124) return stbi__errpuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = stbi__get16le(s); + s->img_y = stbi__get16le(s); + } else { + s->img_x = stbi__get32le(s); + s->img_y = stbi__get32le(s); + } + if (stbi__get16le(s) != 1) return stbi__errpuc("bad BMP", "bad BMP"); + info->bpp = stbi__get16le(s); + if (hsz != 12) { + int compress = stbi__get32le(s); + if (compress == 1 || compress == 2) return stbi__errpuc("BMP RLE", "BMP type not supported: RLE"); + if (compress >= 4) return stbi__errpuc("BMP JPEG/PNG", "BMP type not supported: unsupported compression"); // this includes PNG/JPEG modes + if (compress == 3 && info->bpp != 16 && info->bpp != 32) return stbi__errpuc("bad BMP", "bad BMP"); // bitfields requires 16 or 32 bits/pixel + stbi__get32le(s); // discard sizeof + stbi__get32le(s); // discard hres + stbi__get32le(s); // discard vres + stbi__get32le(s); // discard colorsused + stbi__get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + stbi__get32le(s); + } + if (info->bpp == 16 || info->bpp == 32) { + if (compress == 0) { + stbi__bmp_set_mask_defaults(info, compress); + } else if (compress == 3) { + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->extra_read += 12; + // not documented, but generated by photoshop and handled by mspaint + if (info->mr == info->mg && info->mg == info->mb) { + // ?!?!? + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else + return stbi__errpuc("bad BMP", "bad BMP"); + } + } else { + // V4/V5 header + int i; + if (hsz != 108 && hsz != 124) + return stbi__errpuc("bad BMP", "bad BMP"); + info->mr = stbi__get32le(s); + info->mg = stbi__get32le(s); + info->mb = stbi__get32le(s); + info->ma = stbi__get32le(s); + if (compress != 3) // override mr/mg/mb unless in BI_BITFIELDS mode, as per docs + stbi__bmp_set_mask_defaults(info, compress); + stbi__get32le(s); // discard color space + for (i=0; i < 12; ++i) + stbi__get32le(s); // discard color space parameters + if (hsz == 124) { + stbi__get32le(s); // discard rendering intent + stbi__get32le(s); // discard offset of profile data + stbi__get32le(s); // discard size of profile data + stbi__get32le(s); // discard reserved + } + } + } + return (void *) 1; +} + + +static void *stbi__bmp_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + unsigned int mr=0,mg=0,mb=0,ma=0, all_a; + stbi_uc pal[256][4]; + int psize=0,i,j,width; + int flip_vertically, pad, target; + stbi__bmp_data info; + STBI_NOTUSED(ri); + + info.all_a = 255; + if (stbi__bmp_parse_header(s, &info) == NULL) + return NULL; // error code already set + + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + mr = info.mr; + mg = info.mg; + mb = info.mb; + ma = info.ma; + all_a = info.all_a; + + if (info.hsz == 12) { + if (info.bpp < 24) + psize = (info.offset - info.extra_read - 24) / 3; + } else { + if (info.bpp < 16) + psize = (info.offset - info.extra_read - info.hsz) >> 2; + } + if (psize == 0) { + // accept some number of extra bytes after the header, but if the offset points either to before + // the header ends or implies a large amount of extra data, reject the file as malformed + int bytes_read_so_far = s->callback_already_read + (int)(s->img_buffer - s->img_buffer_original); + int header_limit = 1024; // max we actually read is below 256 bytes currently. + int extra_data_limit = 256*4; // what ordinarily goes here is a palette; 256 entries*4 bytes is its max size. + if (bytes_read_so_far <= 0 || bytes_read_so_far > header_limit) { + return stbi__errpuc("bad header", "Corrupt BMP"); + } + // we established that bytes_read_so_far is positive and sensible. + // the first half of this test rejects offsets that are either too small positives, or + // negative, and guarantees that info.offset >= bytes_read_so_far > 0. this in turn + // ensures the number computed in the second half of the test can't overflow. + if (info.offset < bytes_read_so_far || info.offset - bytes_read_so_far > extra_data_limit) { + return stbi__errpuc("bad offset", "Corrupt BMP"); + } else { + stbi__skip(s, info.offset - bytes_read_so_far); + } + } + + if (info.bpp == 24 && ma == 0xff000000) + s->img_n = 3; + else + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + + // sanity-check size + if (!stbi__mad3sizes_valid(target, s->img_x, s->img_y, 0)) + return stbi__errpuc("too large", "Corrupt BMP"); + + out = (stbi_uc *) stbi__malloc_mad3(target, s->img_x, s->img_y, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (info.bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { STBI_FREE(out); return stbi__errpuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + if (info.hsz != 12) stbi__get8(s); + pal[i][3] = 255; + } + stbi__skip(s, info.offset - info.extra_read - info.hsz - psize * (info.hsz == 12 ? 3 : 4)); + if (info.bpp == 1) width = (s->img_x + 7) >> 3; + else if (info.bpp == 4) width = (s->img_x + 1) >> 1; + else if (info.bpp == 8) width = s->img_x; + else { STBI_FREE(out); return stbi__errpuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + if (info.bpp == 1) { + for (j=0; j < (int) s->img_y; ++j) { + int bit_offset = 7, v = stbi__get8(s); + for (i=0; i < (int) s->img_x; ++i) { + int color = (v>>bit_offset)&0x1; + out[z++] = pal[color][0]; + out[z++] = pal[color][1]; + out[z++] = pal[color][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + if((--bit_offset) < 0) { + bit_offset = 7; + v = stbi__get8(s); + } + } + stbi__skip(s, pad); + } + } else { + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=stbi__get8(s),v2=0; + if (info.bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (info.bpp == 8) ? stbi__get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + stbi__skip(s, pad); + } + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + stbi__skip(s, info.offset - info.extra_read - info.hsz); + if (info.bpp == 24) width = 3 * s->img_x; + else if (info.bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (info.bpp == 24) { + easy = 1; + } else if (info.bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0x00ff0000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + // right shift amt to put high bit in position #7 + rshift = stbi__high_bit(mr)-7; rcount = stbi__bitcount(mr); + gshift = stbi__high_bit(mg)-7; gcount = stbi__bitcount(mg); + bshift = stbi__high_bit(mb)-7; bcount = stbi__bitcount(mb); + ashift = stbi__high_bit(ma)-7; acount = stbi__bitcount(ma); + if (rcount > 8 || gcount > 8 || bcount > 8 || acount > 8) { STBI_FREE(out); return stbi__errpuc("bad masks", "Corrupt BMP"); } + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + unsigned char a; + out[z+2] = stbi__get8(s); + out[z+1] = stbi__get8(s); + out[z+0] = stbi__get8(s); + z += 3; + a = (easy == 2 ? stbi__get8(s) : 255); + all_a |= a; + if (target == 4) out[z++] = a; + } + } else { + int bpp = info.bpp; + for (i=0; i < (int) s->img_x; ++i) { + stbi__uint32 v = (bpp == 16 ? (stbi__uint32) stbi__get16le(s) : stbi__get32le(s)); + unsigned int a; + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mr, rshift, rcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mg, gshift, gcount)); + out[z++] = STBI__BYTECAST(stbi__shiftsigned(v & mb, bshift, bcount)); + a = (ma ? stbi__shiftsigned(v & ma, ashift, acount) : 255); + all_a |= a; + if (target == 4) out[z++] = STBI__BYTECAST(a); + } + } + stbi__skip(s, pad); + } + } + + // if alpha channel is all 0s, replace with all 255s + if (target == 4 && all_a == 0) + for (i=4*s->img_x*s->img_y-1; i >= 0; i -= 4) + out[i] = 255; + + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i]; p1[i] = p2[i]; p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = stbi__convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + return out; +} +#endif + +// Targa Truevision - TGA +// by Jonathan Dummer +#ifndef STBI_NO_TGA +// returns STBI_rgb or whatever, 0 on error +static int stbi__tga_get_comp(int bits_per_pixel, int is_grey, int* is_rgb16) +{ + // only RGB or RGBA (incl. 16bit) or grey allowed + if (is_rgb16) *is_rgb16 = 0; + switch(bits_per_pixel) { + case 8: return STBI_grey; + case 16: if(is_grey) return STBI_grey_alpha; + // fallthrough + case 15: if(is_rgb16) *is_rgb16 = 1; + return STBI_rgb; + case 24: // fallthrough + case 32: return bits_per_pixel/8; + default: return 0; + } +} + +static int stbi__tga_info(stbi__context *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp, tga_image_type, tga_bits_per_pixel, tga_colormap_bpp; + int sz, tga_colormap_type; + stbi__get8(s); // discard Offset + tga_colormap_type = stbi__get8(s); // colormap type + if( tga_colormap_type > 1 ) { + stbi__rewind(s); + return 0; // only RGB or indexed allowed + } + tga_image_type = stbi__get8(s); // image type + if ( tga_colormap_type == 1 ) { // colormapped (paletted) image + if (tga_image_type != 1 && tga_image_type != 9) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) { + stbi__rewind(s); + return 0; + } + stbi__skip(s,4); // skip image x and y origin + tga_colormap_bpp = sz; + } else { // "normal" image w/o colormap - only RGB or grey allowed, +/- RLE + if ( (tga_image_type != 2) && (tga_image_type != 3) && (tga_image_type != 10) && (tga_image_type != 11) ) { + stbi__rewind(s); + return 0; // only RGB or grey allowed, +/- RLE + } + stbi__skip(s,9); // skip colormap specification and image x/y origin + tga_colormap_bpp = 0; + } + tga_w = stbi__get16le(s); + if( tga_w < 1 ) { + stbi__rewind(s); + return 0; // test width + } + tga_h = stbi__get16le(s); + if( tga_h < 1 ) { + stbi__rewind(s); + return 0; // test height + } + tga_bits_per_pixel = stbi__get8(s); // bits per pixel + stbi__get8(s); // ignore alpha bits + if (tga_colormap_bpp != 0) { + if((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16)) { + // when using a colormap, tga_bits_per_pixel is the size of the indexes + // I don't think anything but 8 or 16bit indexes makes sense + stbi__rewind(s); + return 0; + } + tga_comp = stbi__tga_get_comp(tga_colormap_bpp, 0, NULL); + } else { + tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3) || (tga_image_type == 11), NULL); + } + if(!tga_comp) { + stbi__rewind(s); + return 0; + } + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp; + return 1; // seems to have passed everything +} + +static int stbi__tga_test(stbi__context *s) +{ + int res = 0; + int sz, tga_color_type; + stbi__get8(s); // discard Offset + tga_color_type = stbi__get8(s); // color type + if ( tga_color_type > 1 ) goto errorEnd; // only RGB or indexed allowed + sz = stbi__get8(s); // image type + if ( tga_color_type == 1 ) { // colormapped (paletted) image + if (sz != 1 && sz != 9) goto errorEnd; // colortype 1 demands image type 1 or 9 + stbi__skip(s,4); // skip index of first colormap entry and number of entries + sz = stbi__get8(s); // check bits per palette color entry + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + stbi__skip(s,4); // skip image x and y origin + } else { // "normal" image w/o colormap + if ( (sz != 2) && (sz != 3) && (sz != 10) && (sz != 11) ) goto errorEnd; // only RGB or grey allowed, +/- RLE + stbi__skip(s,9); // skip colormap specification and image x/y origin + } + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test width + if ( stbi__get16le(s) < 1 ) goto errorEnd; // test height + sz = stbi__get8(s); // bits per pixel + if ( (tga_color_type == 1) && (sz != 8) && (sz != 16) ) goto errorEnd; // for colormapped images, bpp is size of an index + if ( (sz != 8) && (sz != 15) && (sz != 16) && (sz != 24) && (sz != 32) ) goto errorEnd; + + res = 1; // if we got this far, everything's good and we can return 1 instead of 0 + +errorEnd: + stbi__rewind(s); + return res; +} + +// read 16bit value and convert to 24bit RGB +static void stbi__tga_read_rgb16(stbi__context *s, stbi_uc* out) +{ + stbi__uint16 px = (stbi__uint16)stbi__get16le(s); + stbi__uint16 fiveBitMask = 31; + // we have 3 channels with 5bits each + int r = (px >> 10) & fiveBitMask; + int g = (px >> 5) & fiveBitMask; + int b = px & fiveBitMask; + // Note that this saves the data in RGB(A) order, so it doesn't need to be swapped later + out[0] = (stbi_uc)((r * 255)/31); + out[1] = (stbi_uc)((g * 255)/31); + out[2] = (stbi_uc)((b * 255)/31); + + // some people claim that the most significant bit might be used for alpha + // (possibly if an alpha-bit is set in the "image descriptor byte") + // but that only made 16bit test images completely translucent.. + // so let's treat all 15 and 16bit TGAs as RGB with no alpha. +} + +static void *stbi__tga_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + // read in the TGA header stuff + int tga_offset = stbi__get8(s); + int tga_indexed = stbi__get8(s); + int tga_image_type = stbi__get8(s); + int tga_is_RLE = 0; + int tga_palette_start = stbi__get16le(s); + int tga_palette_len = stbi__get16le(s); + int tga_palette_bits = stbi__get8(s); + int tga_x_origin = stbi__get16le(s); + int tga_y_origin = stbi__get16le(s); + int tga_width = stbi__get16le(s); + int tga_height = stbi__get16le(s); + int tga_bits_per_pixel = stbi__get8(s); + int tga_comp, tga_rgb16=0; + int tga_inverted = stbi__get8(s); + // int tga_alpha_bits = tga_inverted & 15; // the 4 lowest bits - unused (useless?) + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4] = {0}; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + STBI_NOTUSED(ri); + STBI_NOTUSED(tga_x_origin); // @TODO + STBI_NOTUSED(tga_y_origin); // @TODO + + if (tga_height > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (tga_width > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) tga_comp = stbi__tga_get_comp(tga_palette_bits, 0, &tga_rgb16); + else tga_comp = stbi__tga_get_comp(tga_bits_per_pixel, (tga_image_type == 3), &tga_rgb16); + + if(!tga_comp) // shouldn't really happen, stbi__tga_test() should have ensured basic consistency + return stbi__errpuc("bad format", "Can't find out TGA pixelformat"); + + // tga info + *x = tga_width; + *y = tga_height; + if (comp) *comp = tga_comp; + + if (!stbi__mad3sizes_valid(tga_width, tga_height, tga_comp, 0)) + return stbi__errpuc("too large", "Corrupt TGA"); + + tga_data = (unsigned char*)stbi__malloc_mad3(tga_width, tga_height, tga_comp, 0); + if (!tga_data) return stbi__errpuc("outofmem", "Out of memory"); + + // skip to the data's starting position (offset usually = 0) + stbi__skip(s, tga_offset ); + + if ( !tga_indexed && !tga_is_RLE && !tga_rgb16 ) { + for (i=0; i < tga_height; ++i) { + int row = tga_inverted ? tga_height -i - 1 : i; + stbi_uc *tga_row = tga_data + row*tga_width*tga_comp; + stbi__getn(s, tga_row, tga_width * tga_comp); + } + } else { + // do I need to load a palette? + if ( tga_indexed) + { + if (tga_palette_len == 0) { /* you have to have at least one entry! */ + STBI_FREE(tga_data); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + + // any data to skip? (offset usually = 0) + stbi__skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)stbi__malloc_mad2(tga_palette_len, tga_comp, 0); + if (!tga_palette) { + STBI_FREE(tga_data); + return stbi__errpuc("outofmem", "Out of memory"); + } + if (tga_rgb16) { + stbi_uc *pal_entry = tga_palette; + STBI_ASSERT(tga_comp == STBI_rgb); + for (i=0; i < tga_palette_len; ++i) { + stbi__tga_read_rgb16(s, pal_entry); + pal_entry += tga_comp; + } + } else if (!stbi__getn(s, tga_palette, tga_palette_len * tga_comp)) { + STBI_FREE(tga_data); + STBI_FREE(tga_palette); + return stbi__errpuc("bad palette", "Corrupt TGA"); + } + } + // load the data + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE stbi__pngchunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = stbi__get8(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in index, then perform the lookup + int pal_idx = (tga_bits_per_pixel == 8) ? stbi__get8(s) : stbi__get16le(s); + if ( pal_idx >= tga_palette_len ) { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_comp; + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else if(tga_rgb16) { + STBI_ASSERT(tga_comp == STBI_rgb); + stbi__tga_read_rgb16(s, raw_data); + } else { + // read in the data raw + for (j = 0; j < tga_comp; ++j) { + raw_data[j] = stbi__get8(s); + } + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + + // copy data + for (j = 0; j < tga_comp; ++j) + tga_data[i*tga_comp+j] = raw_data[j]; + + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * tga_comp; + int index2 = (tga_height - 1 - j) * tga_width * tga_comp; + for (i = tga_width * tga_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + STBI_FREE( tga_palette ); + } + } + + // swap RGB - if the source data was RGB16, it already is in the right order + if (tga_comp >= 3 && !tga_rgb16) + { + unsigned char* tga_pixel = tga_data; + for (i=0; i < tga_width * tga_height; ++i) + { + unsigned char temp = tga_pixel[0]; + tga_pixel[0] = tga_pixel[2]; + tga_pixel[2] = temp; + tga_pixel += tga_comp; + } + } + + // convert to target component count + if (req_comp && req_comp != tga_comp) + tga_data = stbi__convert_format(tga_data, tga_comp, req_comp, tga_width, tga_height); + + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + STBI_NOTUSED(tga_palette_start); + // OK, done + return tga_data; +} +#endif + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +#ifndef STBI_NO_PSD +static int stbi__psd_test(stbi__context *s) +{ + int r = (stbi__get32be(s) == 0x38425053); + stbi__rewind(s); + return r; +} + +static int stbi__psd_decode_rle(stbi__context *s, stbi_uc *p, int pixelCount) +{ + int count, nleft, len; + + count = 0; + while ((nleft = pixelCount - count) > 0) { + len = stbi__get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + if (len > nleft) return 0; // corrupt data + count += len; + while (len) { + *p = stbi__get8(s); + p += 4; + len--; + } + } else if (len > 128) { + stbi_uc val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len = 257 - len; + if (len > nleft) return 0; // corrupt data + val = stbi__get8(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + + return 1; +} + +static void *stbi__psd_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri, int bpc) +{ + int pixelCount; + int channelCount, compression; + int channel, i; + int bitdepth; + int w,h; + stbi_uc *out; + STBI_NOTUSED(ri); + + // Check identifier + if (stbi__get32be(s) != 0x38425053) // "8BPS" + return stbi__errpuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (stbi__get16be(s) != 1) + return stbi__errpuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + stbi__skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) + return stbi__errpuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = stbi__get32be(s); + w = stbi__get32be(s); + + if (h > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (w > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + // Make sure the depth is 8 bits. + bitdepth = stbi__get16be(s); + if (bitdepth != 8 && bitdepth != 16) + return stbi__errpuc("unsupported bit depth", "PSD bit depth is not 8 or 16 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (stbi__get16be(s) != 3) + return stbi__errpuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + stbi__skip(s,stbi__get32be(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + stbi__skip(s, stbi__get32be(s) ); + + // Skip the reserved data. + stbi__skip(s, stbi__get32be(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = stbi__get16be(s); + if (compression > 1) + return stbi__errpuc("bad compression", "PSD has an unknown compression format"); + + // Check size + if (!stbi__mad3sizes_valid(4, w, h, 0)) + return stbi__errpuc("too large", "Corrupt PSD"); + + // Create the destination image. + + if (!compression && bitdepth == 16 && bpc == 16) { + out = (stbi_uc *) stbi__malloc_mad3(8, w, h, 0); + ri->bits_per_channel = 16; + } else + out = (stbi_uc *) stbi__malloc(4 * w*h); + + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceded by a 2-byte data count for each row in the data, + // which we're going to just skip. + stbi__skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + stbi_uc *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++, p += 4) + *p = (channel == 3 ? 255 : 0); + } else { + // Read the RLE data. + if (!stbi__psd_decode_rle(s, p, pixelCount)) { + STBI_FREE(out); + return stbi__errpuc("corrupt", "bad RLE data"); + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit (or 16-bit) value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + if (channel >= channelCount) { + // Fill this channel with default data. + if (bitdepth == 16 && bpc == 16) { + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + stbi__uint16 val = channel == 3 ? 65535 : 0; + for (i = 0; i < pixelCount; i++, q += 4) + *q = val; + } else { + stbi_uc *p = out+channel; + stbi_uc val = channel == 3 ? 255 : 0; + for (i = 0; i < pixelCount; i++, p += 4) + *p = val; + } + } else { + if (ri->bits_per_channel == 16) { // output bpc + stbi__uint16 *q = ((stbi__uint16 *) out) + channel; + for (i = 0; i < pixelCount; i++, q += 4) + *q = (stbi__uint16) stbi__get16be(s); + } else { + stbi_uc *p = out+channel; + if (bitdepth == 16) { // input bpc + for (i = 0; i < pixelCount; i++, p += 4) + *p = (stbi_uc) (stbi__get16be(s) >> 8); + } else { + for (i = 0; i < pixelCount; i++, p += 4) + *p = stbi__get8(s); + } + } + } + } + } + + // remove weird white matte from PSD + if (channelCount >= 4) { + if (ri->bits_per_channel == 16) { + for (i=0; i < w*h; ++i) { + stbi__uint16 *pixel = (stbi__uint16 *) out + 4*i; + if (pixel[3] != 0 && pixel[3] != 65535) { + float a = pixel[3] / 65535.0f; + float ra = 1.0f / a; + float inv_a = 65535.0f * (1 - ra); + pixel[0] = (stbi__uint16) (pixel[0]*ra + inv_a); + pixel[1] = (stbi__uint16) (pixel[1]*ra + inv_a); + pixel[2] = (stbi__uint16) (pixel[2]*ra + inv_a); + } + } + } else { + for (i=0; i < w*h; ++i) { + unsigned char *pixel = out + 4*i; + if (pixel[3] != 0 && pixel[3] != 255) { + float a = pixel[3] / 255.0f; + float ra = 1.0f / a; + float inv_a = 255.0f * (1 - ra); + pixel[0] = (unsigned char) (pixel[0]*ra + inv_a); + pixel[1] = (unsigned char) (pixel[1]*ra + inv_a); + pixel[2] = (unsigned char) (pixel[2]*ra + inv_a); + } + } + } + } + + // convert to desired output format + if (req_comp && req_comp != 4) { + if (ri->bits_per_channel == 16) + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, 4, req_comp, w, h); + else + out = stbi__convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + + if (comp) *comp = 4; + *y = h; + *x = w; + + return out; +} +#endif + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +#ifndef STBI_NO_PIC +static int stbi__pic_is4(stbi__context *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (stbi__get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int stbi__pic_test_core(stbi__context *s) +{ + int i; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + stbi__get8(s); + + if (!stbi__pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} stbi__pic_packet; + +static stbi_uc *stbi__readval(stbi__context *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (stbi__at_eof(s)) return stbi__errpuc("bad file","PIC file too short"); + dest[i]=stbi__get8(s); + } + } + + return dest; +} + +static void stbi__copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *stbi__pic_load_core(stbi__context *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + stbi__pic_packet packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return stbi__errpuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + + act_comp |= packet->channel; + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return stbi__errpuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return stbi__errpuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=stbi__get8(s); + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (stbi_uc) left; + + if (!stbi__readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = stbi__get8(s), i; + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + + if (count==128) + count = stbi__get16be(s); + else + count -= 127; + if (count > left) + return stbi__errpuc("bad file","scanline overrun"); + + if (!stbi__readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return stbi__errpuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static void *stbi__pic_load(stbi__context *s,int *px,int *py,int *comp,int req_comp, stbi__result_info *ri) +{ + stbi_uc *result; + int i, x,y, internal_comp; + STBI_NOTUSED(ri); + + if (!comp) comp = &internal_comp; + + for (i=0; i<92; ++i) + stbi__get8(s); + + x = stbi__get16be(s); + y = stbi__get16be(s); + + if (y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + if (stbi__at_eof(s)) return stbi__errpuc("bad file","file too short (pic header)"); + if (!stbi__mad3sizes_valid(x, y, 4, 0)) return stbi__errpuc("too large", "PIC image too large to decode"); + + stbi__get32be(s); //skip `ratio' + stbi__get16be(s); //skip `fields' + stbi__get16be(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) stbi__malloc_mad3(x, y, 4, 0); + if (!result) return stbi__errpuc("outofmem", "Out of memory"); + memset(result, 0xff, x*y*4); + + if (!stbi__pic_load_core(s,x,y,comp, result)) { + STBI_FREE(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=stbi__convert_format(result,4,req_comp,x,y); + + return result; +} + +static int stbi__pic_test(stbi__context *s) +{ + int r = stbi__pic_test_core(s); + stbi__rewind(s); + return r; +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb + +#ifndef STBI_NO_GIF +typedef struct +{ + stbi__int16 prefix; + stbi_uc first; + stbi_uc suffix; +} stbi__gif_lzw; + +typedef struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + stbi_uc *background; // The current "background" as far as a gif is concerned + stbi_uc *history; + int flags, bgindex, ratio, transparent, eflags; + stbi_uc pal[256][4]; + stbi_uc lpal[256][4]; + stbi__gif_lzw codes[8192]; + stbi_uc *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; + int delay; +} stbi__gif; + +static int stbi__gif_test_raw(stbi__context *s) +{ + int sz; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') return 0; + sz = stbi__get8(s); + if (sz != '9' && sz != '7') return 0; + if (stbi__get8(s) != 'a') return 0; + return 1; +} + +static int stbi__gif_test(stbi__context *s) +{ + int r = stbi__gif_test_raw(s); + stbi__rewind(s); + return r; +} + +static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = stbi__get8(s); + pal[i][1] = stbi__get8(s); + pal[i][0] = stbi__get8(s); + pal[i][3] = transp == i ? 0 : 255; + } +} + +static int stbi__gif_header(stbi__context *s, stbi__gif *g, int *comp, int is_info) +{ + stbi_uc version; + if (stbi__get8(s) != 'G' || stbi__get8(s) != 'I' || stbi__get8(s) != 'F' || stbi__get8(s) != '8') + return stbi__err("not GIF", "Corrupt GIF"); + + version = stbi__get8(s); + if (version != '7' && version != '9') return stbi__err("not GIF", "Corrupt GIF"); + if (stbi__get8(s) != 'a') return stbi__err("not GIF", "Corrupt GIF"); + + stbi__g_failure_reason = ""; + g->w = stbi__get16le(s); + g->h = stbi__get16le(s); + g->flags = stbi__get8(s); + g->bgindex = stbi__get8(s); + g->ratio = stbi__get8(s); + g->transparent = -1; + + if (g->w > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + if (g->h > STBI_MAX_DIMENSIONS) return stbi__err("too large","Very large image (corrupt?)"); + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi__gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi__gif_info_raw(stbi__context *s, int *x, int *y, int *comp) +{ + stbi__gif* g = (stbi__gif*) stbi__malloc(sizeof(stbi__gif)); + if (!g) return stbi__err("outofmem", "Out of memory"); + if (!stbi__gif_header(s, g, comp, 1)) { + STBI_FREE(g); + stbi__rewind( s ); + return 0; + } + if (x) *x = g->w; + if (y) *y = g->h; + STBI_FREE(g); + return 1; +} + +static void stbi__out_gif_code(stbi__gif *g, stbi__uint16 code) +{ + stbi_uc *p, *c; + int idx; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi__out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + idx = g->cur_x + g->cur_y; + p = &g->out[idx]; + g->history[idx / 4] = 1; + + c = &g->color_table[g->codes[code].suffix * 4]; + if (c[3] > 128) { // don't render transparent pixels; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static stbi_uc *stbi__process_gif_raster(stbi__context *s, stbi__gif *g) +{ + stbi_uc lzw_cs; + stbi__int32 len, init_code; + stbi__uint32 first; + stbi__int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi__gif_lzw *p; + + lzw_cs = stbi__get8(s); + if (lzw_cs > 12) return NULL; + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (init_code = 0; init_code < clear; init_code++) { + g->codes[init_code].prefix = -1; + g->codes[init_code].first = (stbi_uc) init_code; + g->codes[init_code].suffix = (stbi_uc) init_code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = stbi__get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (stbi__int32) stbi__get8(s) << valid_bits; + valid_bits += 8; + } else { + stbi__int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + stbi__skip(s, len); + while ((len = stbi__get8(s)) > 0) + stbi__skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) { + return stbi__errpuc("no clear code", "Corrupt GIF"); + } + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 8192) { + return stbi__errpuc("too many codes", "Corrupt GIF"); + } + + p->prefix = (stbi__int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + + stbi__out_gif_code(g, (stbi__uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return stbi__errpuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +// two back is the image from two frames ago, used for a very specific disposal format +static stbi_uc *stbi__gif_load_next(stbi__context *s, stbi__gif *g, int *comp, int req_comp, stbi_uc *two_back) +{ + int dispose; + int first_frame; + int pi; + int pcount; + STBI_NOTUSED(req_comp); + + // on first frame, any non-written pixels get the background colour (non-transparent) + first_frame = 0; + if (g->out == 0) { + if (!stbi__gif_header(s, g, comp,0)) return 0; // stbi__g_failure_reason set by stbi__gif_header + if (!stbi__mad3sizes_valid(4, g->w, g->h, 0)) + return stbi__errpuc("too large", "GIF image is too large"); + pcount = g->w * g->h; + g->out = (stbi_uc *) stbi__malloc(4 * pcount); + g->background = (stbi_uc *) stbi__malloc(4 * pcount); + g->history = (stbi_uc *) stbi__malloc(pcount); + if (!g->out || !g->background || !g->history) + return stbi__errpuc("outofmem", "Out of memory"); + + // image is treated as "transparent" at the start - ie, nothing overwrites the current background; + // background colour is only used for pixels that are not rendered first frame, after that "background" + // color refers to the color that was there the previous frame. + memset(g->out, 0x00, 4 * pcount); + memset(g->background, 0x00, 4 * pcount); // state of the background (starts transparent) + memset(g->history, 0x00, pcount); // pixels that were affected previous frame + first_frame = 1; + } else { + // second frame - how do we dispose of the previous one? + dispose = (g->eflags & 0x1C) >> 2; + pcount = g->w * g->h; + + if ((dispose == 3) && (two_back == 0)) { + dispose = 2; // if I don't have an image to revert back to, default to the old background + } + + if (dispose == 3) { // use previous graphic + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &two_back[pi * 4], 4 ); + } + } + } else if (dispose == 2) { + // restore what was changed last frame to background before that frame; + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi]) { + memcpy( &g->out[pi * 4], &g->background[pi * 4], 4 ); + } + } + } else { + // This is a non-disposal case eithe way, so just + // leave the pixels as is, and they will become the new background + // 1: do not dispose + // 0: not specified. + } + + // background is what out is after the undoing of the previou frame; + memcpy( g->background, g->out, 4 * g->w * g->h ); + } + + // clear my history; + memset( g->history, 0x00, g->w * g->h ); // pixels that were affected previous frame + + for (;;) { + int tag = stbi__get8(s); + switch (tag) { + case 0x2C: /* Image Descriptor */ + { + stbi__int32 x, y, w, h; + stbi_uc *o; + + x = stbi__get16le(s); + y = stbi__get16le(s); + w = stbi__get16le(s); + h = stbi__get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return stbi__errpuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + // if the width of the specified rectangle is 0, that means + // we may not see *any* pixels or the image is malformed; + // to make sure this is caught, move the current y down to + // max_y (which is what out_gif_code checks). + if (w == 0) + g->cur_y = g->max_y; + + g->lflags = stbi__get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi__gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (stbi_uc *) g->lpal; + } else if (g->flags & 0x80) { + g->color_table = (stbi_uc *) g->pal; + } else + return stbi__errpuc("missing color table", "Corrupt GIF"); + + o = stbi__process_gif_raster(s, g); + if (!o) return NULL; + + // if this was the first frame, + pcount = g->w * g->h; + if (first_frame && (g->bgindex > 0)) { + // if first frame, any pixel not drawn to gets the background color + for (pi = 0; pi < pcount; ++pi) { + if (g->history[pi] == 0) { + g->pal[g->bgindex][3] = 255; // just in case it was made transparent, undo that; It will be reset next frame if need be; + memcpy( &g->out[pi * 4], &g->pal[g->bgindex], 4 ); + } + } + } + + return o; + } + + case 0x21: // Comment Extension. + { + int len; + int ext = stbi__get8(s); + if (ext == 0xF9) { // Graphic Control Extension. + len = stbi__get8(s); + if (len == 4) { + g->eflags = stbi__get8(s); + g->delay = 10 * stbi__get16le(s); // delay - 1/100th of a second, saving as 1/1000ths. + + // unset old transparent + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 255; + } + if (g->eflags & 0x01) { + g->transparent = stbi__get8(s); + if (g->transparent >= 0) { + g->pal[g->transparent][3] = 0; + } + } else { + // don't need transparent + stbi__skip(s, 1); + g->transparent = -1; + } + } else { + stbi__skip(s, len); + break; + } + } + while ((len = stbi__get8(s)) != 0) { + stbi__skip(s, len); + } + break; + } + + case 0x3B: // gif stream termination code + return (stbi_uc *) s; // using '1' causes warning on some compilers + + default: + return stbi__errpuc("unknown code", "Corrupt GIF"); + } + } +} + +static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays) +{ + STBI_FREE(g->out); + STBI_FREE(g->history); + STBI_FREE(g->background); + + if (out) STBI_FREE(out); + if (delays && *delays) STBI_FREE(*delays); + return stbi__errpuc("outofmem", "Out of memory"); +} + +static void *stbi__load_gif_main(stbi__context *s, int **delays, int *x, int *y, int *z, int *comp, int req_comp) +{ + if (stbi__gif_test(s)) { + int layers = 0; + stbi_uc *u = 0; + stbi_uc *out = 0; + stbi_uc *two_back = 0; + stbi__gif g; + int stride; + int out_size = 0; + int delays_size = 0; + + STBI_NOTUSED(out_size); + STBI_NOTUSED(delays_size); + + memset(&g, 0, sizeof(g)); + if (delays) { + *delays = 0; + } + + do { + u = stbi__gif_load_next(s, &g, comp, req_comp, two_back); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + + if (u) { + *x = g.w; + *y = g.h; + ++layers; + stride = g.w * g.h * 4; + + if (out) { + void *tmp = (stbi_uc*) STBI_REALLOC_SIZED( out, out_size, layers * stride ); + if (!tmp) + return stbi__load_gif_main_outofmem(&g, out, delays); + else { + out = (stbi_uc*) tmp; + out_size = layers * stride; + } + + if (delays) { + int *new_delays = (int*) STBI_REALLOC_SIZED( *delays, delays_size, sizeof(int) * layers ); + if (!new_delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + *delays = new_delays; + delays_size = layers * sizeof(int); + } + } else { + out = (stbi_uc*)stbi__malloc( layers * stride ); + if (!out) + return stbi__load_gif_main_outofmem(&g, out, delays); + out_size = layers * stride; + if (delays) { + *delays = (int*) stbi__malloc( layers * sizeof(int) ); + if (!*delays) + return stbi__load_gif_main_outofmem(&g, out, delays); + delays_size = layers * sizeof(int); + } + } + memcpy( out + ((layers - 1) * stride), u, stride ); + if (layers >= 2) { + two_back = out - 2 * stride; + } + + if (delays) { + (*delays)[layers - 1U] = g.delay; + } + } + } while (u != 0); + + // free temp buffer; + STBI_FREE(g.out); + STBI_FREE(g.history); + STBI_FREE(g.background); + + // do the final conversion after loading everything; + if (req_comp && req_comp != 4) + out = stbi__convert_format(out, 4, req_comp, layers * g.w, g.h); + + *z = layers; + return out; + } else { + return stbi__errpuc("not GIF", "Image was not as a gif type."); + } +} + +static void *stbi__gif_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *u = 0; + stbi__gif g; + memset(&g, 0, sizeof(g)); + STBI_NOTUSED(ri); + + u = stbi__gif_load_next(s, &g, comp, req_comp, 0); + if (u == (stbi_uc *) s) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + + // moved conversion to after successful load so that the same + // can be done for multiple frames. + if (req_comp && req_comp != 4) + u = stbi__convert_format(u, 4, req_comp, g.w, g.h); + } else if (g.out) { + // if there was an error and we allocated an image buffer, free it! + STBI_FREE(g.out); + } + + // free buffers needed for multiple frame loading; + STBI_FREE(g.history); + STBI_FREE(g.background); + + return u; +} + +static int stbi__gif_info(stbi__context *s, int *x, int *y, int *comp) +{ + return stbi__gif_info_raw(s,x,y,comp); +} +#endif + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int stbi__hdr_test_core(stbi__context *s, const char *signature) +{ + int i; + for (i=0; signature[i]; ++i) + if (stbi__get8(s) != signature[i]) + return 0; + stbi__rewind(s); + return 1; +} + +static int stbi__hdr_test(stbi__context* s) +{ + int r = stbi__hdr_test_core(s, "#?RADIANCE\n"); + stbi__rewind(s); + if(!r) { + r = stbi__hdr_test_core(s, "#?RGBE\n"); + stbi__rewind(s); + } + return r; +} + +#define STBI__HDR_BUFLEN 1024 +static char *stbi__hdr_gettoken(stbi__context *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) stbi__get8(z); + + while (!stbi__at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == STBI__HDR_BUFLEN-1) { + // flush to end of line + while (!stbi__at_eof(z) && stbi__get8(z) != '\n') + ; + break; + } + c = (char) stbi__get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void stbi__hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + +static float *stbi__hdr_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + const char *headerToken; + STBI_NOTUSED(ri); + + // Check identifier + headerToken = stbi__hdr_gettoken(s,buffer); + if (strcmp(headerToken, "#?RADIANCE") != 0 && strcmp(headerToken, "#?RGBE") != 0) + return stbi__errpf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return stbi__errpf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return stbi__errpf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = (int) strtol(token, NULL, 10); + + if (height > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + if (width > STBI_MAX_DIMENSIONS) return stbi__errpf("too large","Very large image (corrupt?)"); + + *x = width; + *y = height; + + if (comp) *comp = 3; + if (req_comp == 0) req_comp = 3; + + if (!stbi__mad4sizes_valid(width, height, req_comp, sizeof(float), 0)) + return stbi__errpf("too large", "HDR image is too large"); + + // Read data + hdr_data = (float *) stbi__malloc_mad4(width, height, req_comp, sizeof(float), 0); + if (!hdr_data) + return stbi__errpf("outofmem", "Out of memory"); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + stbi__getn(s, rgbe, 4); + stbi__hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = stbi__get8(s); + c2 = stbi__get8(s); + len = stbi__get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + stbi_uc rgbe[4]; + rgbe[0] = (stbi_uc) c1; + rgbe[1] = (stbi_uc) c2; + rgbe[2] = (stbi_uc) len; + rgbe[3] = (stbi_uc) stbi__get8(s); + stbi__hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + STBI_FREE(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= stbi__get8(s); + if (len != width) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) { + scanline = (stbi_uc *) stbi__malloc_mad2(width, 4, 0); + if (!scanline) { + STBI_FREE(hdr_data); + return stbi__errpf("outofmem", "Out of memory"); + } + } + + for (k = 0; k < 4; ++k) { + int nleft; + i = 0; + while ((nleft = width - i) > 0) { + count = stbi__get8(s); + if (count > 128) { + // Run + value = stbi__get8(s); + count -= 128; + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + if ((count == 0) || (count > nleft)) { STBI_FREE(hdr_data); STBI_FREE(scanline); return stbi__errpf("corrupt", "bad RLE data in HDR"); } + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = stbi__get8(s); + } + } + } + for (i=0; i < width; ++i) + stbi__hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + if (scanline) + STBI_FREE(scanline); + } + + return hdr_data; +} + +static int stbi__hdr_info(stbi__context *s, int *x, int *y, int *comp) +{ + char buffer[STBI__HDR_BUFLEN]; + char *token; + int valid = 0; + int dummy; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (stbi__hdr_test(s) == 0) { + stbi__rewind( s ); + return 0; + } + + for(;;) { + token = stbi__hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) { + stbi__rewind( s ); + return 0; + } + token = stbi__hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *y = (int) strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) { + stbi__rewind( s ); + return 0; + } + token += 3; + *x = (int) strtol(token, NULL, 10); + *comp = 3; + return 1; +} +#endif // STBI_NO_HDR + +#ifndef STBI_NO_BMP +static int stbi__bmp_info(stbi__context *s, int *x, int *y, int *comp) +{ + void *p; + stbi__bmp_data info; + + info.all_a = 255; + p = stbi__bmp_parse_header(s, &info); + if (p == NULL) { + stbi__rewind( s ); + return 0; + } + if (x) *x = s->img_x; + if (y) *y = s->img_y; + if (comp) { + if (info.bpp == 24 && info.ma == 0xff000000) + *comp = 3; + else + *comp = info.ma ? 4 : 3; + } + return 1; +} +#endif + +#ifndef STBI_NO_PSD +static int stbi__psd_info(stbi__context *s, int *x, int *y, int *comp) +{ + int channelCount, dummy, depth; + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + *y = stbi__get32be(s); + *x = stbi__get32be(s); + depth = stbi__get16be(s); + if (depth != 8 && depth != 16) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 3) { + stbi__rewind( s ); + return 0; + } + *comp = 4; + return 1; +} + +static int stbi__psd_is16(stbi__context *s) +{ + int channelCount, depth; + if (stbi__get32be(s) != 0x38425053) { + stbi__rewind( s ); + return 0; + } + if (stbi__get16be(s) != 1) { + stbi__rewind( s ); + return 0; + } + stbi__skip(s, 6); + channelCount = stbi__get16be(s); + if (channelCount < 0 || channelCount > 16) { + stbi__rewind( s ); + return 0; + } + STBI_NOTUSED(stbi__get32be(s)); + STBI_NOTUSED(stbi__get32be(s)); + depth = stbi__get16be(s); + if (depth != 16) { + stbi__rewind( s ); + return 0; + } + return 1; +} +#endif + +#ifndef STBI_NO_PIC +static int stbi__pic_info(stbi__context *s, int *x, int *y, int *comp) +{ + int act_comp=0,num_packets=0,chained,dummy; + stbi__pic_packet packets[10]; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + if (!stbi__pic_is4(s,"\x53\x80\xF6\x34")) { + stbi__rewind(s); + return 0; + } + + stbi__skip(s, 88); + + *x = stbi__get16be(s); + *y = stbi__get16be(s); + if (stbi__at_eof(s)) { + stbi__rewind( s); + return 0; + } + if ( (*x) != 0 && (1 << 28) / (*x) < (*y)) { + stbi__rewind( s ); + return 0; + } + + stbi__skip(s, 8); + + do { + stbi__pic_packet *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return 0; + + packet = &packets[num_packets++]; + chained = stbi__get8(s); + packet->size = stbi__get8(s); + packet->type = stbi__get8(s); + packet->channel = stbi__get8(s); + act_comp |= packet->channel; + + if (stbi__at_eof(s)) { + stbi__rewind( s ); + return 0; + } + if (packet->size != 8) { + stbi__rewind( s ); + return 0; + } + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); + + return 1; +} +#endif + +// ************************************************************************************************* +// Portable Gray Map and Portable Pixel Map loader +// by Ken Miller +// +// PGM: http://netpbm.sourceforge.net/doc/pgm.html +// PPM: http://netpbm.sourceforge.net/doc/ppm.html +// +// Known limitations: +// Does not support comments in the header section +// Does not support ASCII image data (formats P2 and P3) + +#ifndef STBI_NO_PNM + +static int stbi__pnm_test(stbi__context *s) +{ + char p, t; + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind( s ); + return 0; + } + return 1; +} + +static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri) +{ + stbi_uc *out; + STBI_NOTUSED(ri); + + ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n); + if (ri->bits_per_channel == 0) + return 0; + + if (s->img_y > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + if (s->img_x > STBI_MAX_DIMENSIONS) return stbi__errpuc("too large","Very large image (corrupt?)"); + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = s->img_n; + + if (!stbi__mad4sizes_valid(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0)) + return stbi__errpuc("too large", "PNM too large"); + + out = (stbi_uc *) stbi__malloc_mad4(s->img_n, s->img_x, s->img_y, ri->bits_per_channel / 8, 0); + if (!out) return stbi__errpuc("outofmem", "Out of memory"); + if (!stbi__getn(s, out, s->img_n * s->img_x * s->img_y * (ri->bits_per_channel / 8))) { + STBI_FREE(out); + return stbi__errpuc("bad PNM", "PNM file truncated"); + } + + if (req_comp && req_comp != s->img_n) { + if (ri->bits_per_channel == 16) { + out = (stbi_uc *) stbi__convert_format16((stbi__uint16 *) out, s->img_n, req_comp, s->img_x, s->img_y); + } else { + out = stbi__convert_format(out, s->img_n, req_comp, s->img_x, s->img_y); + } + if (out == NULL) return out; // stbi__convert_format frees input on failure + } + return out; +} + +static int stbi__pnm_isspace(char c) +{ + return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r'; +} + +static void stbi__pnm_skip_whitespace(stbi__context *s, char *c) +{ + for (;;) { + while (!stbi__at_eof(s) && stbi__pnm_isspace(*c)) + *c = (char) stbi__get8(s); + + if (stbi__at_eof(s) || *c != '#') + break; + + while (!stbi__at_eof(s) && *c != '\n' && *c != '\r' ) + *c = (char) stbi__get8(s); + } +} + +static int stbi__pnm_isdigit(char c) +{ + return c >= '0' && c <= '9'; +} + +static int stbi__pnm_getinteger(stbi__context *s, char *c) +{ + int value = 0; + + while (!stbi__at_eof(s) && stbi__pnm_isdigit(*c)) { + value = value*10 + (*c - '0'); + *c = (char) stbi__get8(s); + if((value > 214748364) || (value == 214748364 && *c > '7')) + return stbi__err("integer parse overflow", "Parsing an integer in the PPM header overflowed a 32-bit int"); + } + + return value; +} + +static int stbi__pnm_info(stbi__context *s, int *x, int *y, int *comp) +{ + int maxv, dummy; + char c, p, t; + + if (!x) x = &dummy; + if (!y) y = &dummy; + if (!comp) comp = &dummy; + + stbi__rewind(s); + + // Get identifier + p = (char) stbi__get8(s); + t = (char) stbi__get8(s); + if (p != 'P' || (t != '5' && t != '6')) { + stbi__rewind(s); + return 0; + } + + *comp = (t == '6') ? 3 : 1; // '5' is 1-component .pgm; '6' is 3-component .ppm + + c = (char) stbi__get8(s); + stbi__pnm_skip_whitespace(s, &c); + + *x = stbi__pnm_getinteger(s, &c); // read width + if(*x == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + *y = stbi__pnm_getinteger(s, &c); // read height + if (*y == 0) + return stbi__err("invalid width", "PPM image header had zero or overflowing width"); + stbi__pnm_skip_whitespace(s, &c); + + maxv = stbi__pnm_getinteger(s, &c); // read max value + if (maxv > 65535) + return stbi__err("max value > 65535", "PPM image supports only 8-bit and 16-bit images"); + else if (maxv > 255) + return 16; + else + return 8; +} + +static int stbi__pnm_is16(stbi__context *s) +{ + if (stbi__pnm_info(s, NULL, NULL, NULL) == 16) + return 1; + return 0; +} +#endif + +static int stbi__info_main(stbi__context *s, int *x, int *y, int *comp) +{ + #ifndef STBI_NO_JPEG + if (stbi__jpeg_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNG + if (stbi__png_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_GIF + if (stbi__gif_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_BMP + if (stbi__bmp_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PIC + if (stbi__pic_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_info(s, x, y, comp)) return 1; + #endif + + #ifndef STBI_NO_HDR + if (stbi__hdr_info(s, x, y, comp)) return 1; + #endif + + // test tga last because it's a crappy test! + #ifndef STBI_NO_TGA + if (stbi__tga_info(s, x, y, comp)) + return 1; + #endif + return stbi__err("unknown image type", "Image not of any known type, or corrupt"); +} + +static int stbi__is_16_main(stbi__context *s) +{ + #ifndef STBI_NO_PNG + if (stbi__png_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PSD + if (stbi__psd_is16(s)) return 1; + #endif + + #ifndef STBI_NO_PNM + if (stbi__pnm_is16(s)) return 1; + #endif + return 0; +} + +#ifndef STBI_NO_STDIO +STBIDEF int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +STBIDEF int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__info_main(&s,x,y,comp); + fseek(f,pos,SEEK_SET); + return r; +} + +STBIDEF int stbi_is_16_bit(char const *filename) +{ + FILE *f = stbi__fopen(filename, "rb"); + int result; + if (!f) return stbi__err("can't fopen", "Unable to open file"); + result = stbi_is_16_bit_from_file(f); + fclose(f); + return result; +} + +STBIDEF int stbi_is_16_bit_from_file(FILE *f) +{ + int r; + stbi__context s; + long pos = ftell(f); + stbi__start_file(&s, f); + r = stbi__is_16_main(&s); + fseek(f,pos,SEEK_SET); + return r; +} +#endif // !STBI_NO_STDIO + +STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__info_main(&s,x,y,comp); +} + +STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len) +{ + stbi__context s; + stbi__start_mem(&s,buffer,len); + return stbi__is_16_main(&s); +} + +STBIDEF int stbi_is_16_bit_from_callbacks(stbi_io_callbacks const *c, void *user) +{ + stbi__context s; + stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user); + return stbi__is_16_main(&s); +} + +#endif // STB_IMAGE_IMPLEMENTATION + +/* + revision history: + 2.20 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs + 2.19 (2018-02-11) fix warning + 2.18 (2018-01-30) fix warnings + 2.17 (2018-01-29) change sbti__shiftsigned to avoid clang -O2 bug + 1-bit BMP + *_is_16_bit api + avoid warnings + 2.16 (2017-07-23) all functions have 16-bit variants; + STBI_NO_STDIO works again; + compilation fixes; + fix rounding in unpremultiply; + optimize vertical flip; + disable raw_len validation; + documentation fixes + 2.15 (2017-03-18) fix png-1,2,4 bug; now all Imagenet JPGs decode; + warning fixes; disable run-time SSE detection on gcc; + uniform handling of optional "return" values; + thread-safe initialization of zlib tables + 2.14 (2017-03-03) remove deprecated STBI_JPEG_OLD; fixes for Imagenet JPGs + 2.13 (2016-11-29) add 16-bit API, only supported for PNG right now + 2.12 (2016-04-02) fix typo in 2.11 PSD fix that caused crashes + 2.11 (2016-04-02) allocate large structures on the stack + remove white matting for transparent PSD + fix reported channel count for PNG & BMP + re-enable SSE2 in non-gcc 64-bit + support RGB-formatted JPEG + read 16-bit PNGs (only as 8-bit) + 2.10 (2016-01-22) avoid warning introduced in 2.09 by STBI_REALLOC_SIZED + 2.09 (2016-01-16) allow comments in PNM files + 16-bit-per-pixel TGA (not bit-per-component) + info() for TGA could break due to .hdr handling + info() for BMP to shares code instead of sloppy parse + can use STBI_REALLOC_SIZED if allocator doesn't support realloc + code cleanup + 2.08 (2015-09-13) fix to 2.07 cleanup, reading RGB PSD as RGBA + 2.07 (2015-09-13) fix compiler warnings + partial animated GIF support + limited 16-bpc PSD support + #ifdef unused functions + bug with < 92 byte PIC,PNM,HDR,TGA + 2.06 (2015-04-19) fix bug where PSD returns wrong '*comp' value + 2.05 (2015-04-19) fix bug in progressive JPEG handling, fix warning + 2.04 (2015-04-15) try to re-enable SIMD on MinGW 64-bit + 2.03 (2015-04-12) extra corruption checking (mmozeiko) + stbi_set_flip_vertically_on_load (nguillemot) + fix NEON support; fix mingw support + 2.02 (2015-01-19) fix incorrect assert, fix warning + 2.01 (2015-01-17) fix various warnings; suppress SIMD on gcc 32-bit without -msse2 + 2.00b (2014-12-25) fix STBI_MALLOC in progressive JPEG + 2.00 (2014-12-25) optimize JPG, including x86 SSE2 & NEON SIMD (ryg) + progressive JPEG (stb) + PGM/PPM support (Ken Miller) + STBI_MALLOC,STBI_REALLOC,STBI_FREE + GIF bugfix -- seemingly never worked + STBI_NO_*, STBI_ONLY_* + 1.48 (2014-12-14) fix incorrectly-named assert() + 1.47 (2014-12-14) 1/2/4-bit PNG support, both direct and paletted (Omar Cornut & stb) + optimize PNG (ryg) + fix bug in interlaced PNG with user-specified channel count (stb) + 1.46 (2014-08-26) + fix broken tRNS chunk (colorkey-style transparency) in non-paletted PNG + 1.45 (2014-08-16) + fix MSVC-ARM internal compiler error by wrapping malloc + 1.44 (2014-08-07) + various warning fixes from Ronny Chevalier + 1.43 (2014-07-15) + fix MSVC-only compiler problem in code changed in 1.42 + 1.42 (2014-07-09) + don't define _CRT_SECURE_NO_WARNINGS (affects user code) + fixes to stbi__cleanup_jpeg path + added STBI_ASSERT to avoid requiring assert.h + 1.41 (2014-06-25) + fix search&replace from 1.36 that messed up comments/error messages + 1.40 (2014-06-22) + fix gcc struct-initialization warning + 1.39 (2014-06-15) + fix to TGA optimization when req_comp != number of components in TGA; + fix to GIF loading because BMP wasn't rewinding (whoops, no GIFs in my test suite) + add support for BMP version 5 (more ignored fields) + 1.38 (2014-06-06) + suppress MSVC warnings on integer casts truncating values + fix accidental rename of 'skip' field of I/O + 1.37 (2014-06-04) + remove duplicate typedef + 1.36 (2014-06-03) + convert to header file single-file library + if de-iphone isn't set, load iphone images color-swapped instead of returning NULL + 1.35 (2014-05-27) + various warnings + fix broken STBI_SIMD path + fix bug where stbi_load_from_file no longer left file pointer in correct place + fix broken non-easy path for 32-bit BMP (possibly never used) + TGA optimization by Arseny Kapoulkine + 1.34 (unknown) + use STBI_NOTUSED in stbi__resample_row_generic(), fix one more leak in tga failure case + 1.33 (2011-07-14) + make stbi_is_hdr work in STBI_NO_HDR (as specified), minor compiler-friendly improvements + 1.32 (2011-07-13) + support for "info" function for all supported filetypes (SpartanJ) + 1.31 (2011-06-20) + a few more leak fixes, bug in PNG handling (SpartanJ) + 1.30 (2011-06-11) + added ability to load files via callbacks to accomidate custom input streams (Ben Wenger) + removed deprecated format-specific test/load functions + removed support for installable file formats (stbi_loader) -- would have been broken for IO callbacks anyway + error cases in bmp and tga give messages and don't leak (Raymond Barbiero, grisha) + fix inefficiency in decoding 32-bit BMP (David Woo) + 1.29 (2010-08-16) + various warning fixes from Aurelien Pocheville + 1.28 (2010-08-01) + fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-stbi_uc to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.stbi__err. Janez (U+017D)emva) + 1.21 fix use of 'stbi_uc' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 (2008-08-02) + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - stbi__convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi__bmp_load() and stbi__tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant + 0.50 (2006-11-19) + first released version +*/ + + +/* +------------------------------------------------------------------------------ +This software is available under 2 licenses -- choose whichever you prefer. +------------------------------------------------------------------------------ +ALTERNATIVE A - MIT License +Copyright (c) 2017 Sean Barrett +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. +------------------------------------------------------------------------------ +ALTERNATIVE B - Public Domain (www.unlicense.org) +This is free and unencumbered software released into the public domain. +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. +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 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. +------------------------------------------------------------------------------ +*/ diff --git a/11-lightmaps/tests/bad_shader.vs b/11-lightmaps/tests/bad_shader.vs new file mode 100644 index 0000000..6743b8a --- /dev/null +++ b/11-lightmaps/tests/bad_shader.vs @@ -0,0 +1,10 @@ +#version 330 core +layout (location = 0) in vec3 aPos; // the position variable has attribute position 0 + +out vec4 vertexColor; // specify a color output to the fragment shader + +void main() +// syntax error here + gl_Position = vec4(aPos, 1.0); // see how we directly give a vec3 to vec4's constructor + vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // set the output variable to a dark-red color +} diff --git a/11-lightmaps/tests/main.cpp b/11-lightmaps/tests/main.cpp new file mode 100644 index 0000000..48b605b --- /dev/null +++ b/11-lightmaps/tests/main.cpp @@ -0,0 +1,38 @@ +#include +#include +#include +#include "dbc.hpp" + +TEST_SET(shader_tests); + +using namespace fuc2; + +int main(int argc, char* argv[]) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + + GLFWwindow* window = glfwCreateWindow(800, 600, "LearnOpenGL", NULL, NULL); + if (window == NULL) + { + dbc::log("Failed to create GLFW window"); + glfwTerminate(); + return -1; + } + glfwMakeContextCurrent(window); + + // glad: load all OpenGL function pointers + // --------------------------------------- + if(!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) + { + dbc::log("Failed to initialize GLAD"); + return -1; + } + + std::vector tests{ + shader_tests::TESTS + }; + + return run_tests(tests, argc, argv); +} diff --git a/11-lightmaps/tests/meson.build b/11-lightmaps/tests/meson.build new file mode 100644 index 0000000..90c7a91 --- /dev/null +++ b/11-lightmaps/tests/meson.build @@ -0,0 +1,4 @@ +fuc2_tests = files( + 'main.cpp', + 'shader_tests.cpp', +) diff --git a/11-lightmaps/tests/shader_tests.cpp b/11-lightmaps/tests/shader_tests.cpp new file mode 100644 index 0000000..270b921 --- /dev/null +++ b/11-lightmaps/tests/shader_tests.cpp @@ -0,0 +1,33 @@ +#include +#include +#include +#include "shader.hpp" + +using namespace fuc2; + +namespace shader_tests { + void test_load_shaders() { + Shader shader("shaders/3.3.shader.vs", "shaders/3.3.shader.fs"); + + shader.use(); + + CHECK(shader.ID != UINT_MAX, "Shader not initialized"); + } + + void test_compile_fail() { + auto runner = [&]() { + Shader shader("tests/bad_shader.vs", "shaders/3.3.shader.fs"); + }; + + BLOWS_UP(runner, "compile fail should blow up"); + } + + fuc2::Set TESTS{ + .name="shaders", + .options={ .fail_fast=false }, + .tests={ + TEST(test_load_shaders), + TEST(test_compile_fail), + } + }; +} diff --git a/11-lightmaps/wraps/assimp.wrap b/11-lightmaps/wraps/assimp.wrap new file mode 100644 index 0000000..4bb6029 --- /dev/null +++ b/11-lightmaps/wraps/assimp.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=assimp-5.4.3 +url=https://github.com/assimp/assimp.git +revision=v5.4.3 +depth=1 +method=cmake + +[provide] +assimp = assimp_dep diff --git a/11-lightmaps/wraps/box2d.wrap b/11-lightmaps/wraps/box2d.wrap new file mode 100644 index 0000000..d4b2d96 --- /dev/null +++ b/11-lightmaps/wraps/box2d.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = box2d-2.4.1 +source_url = https://github.com/erincatto/box2d/archive/v2.4.1/box2d-2.4.1.tar.gz +source_filename = box2d-2.4.1.tar.gz +source_hash = d6b4650ff897ee1ead27cf77a5933ea197cbeef6705638dd181adc2e816b23c2 +patch_filename = box2d_2.4.1-4_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/box2d_2.4.1-4/get_patch +patch_hash = f5235178029fa0a8deaf8dddbccfd70739b289cffbeec5c98fc91209683c4802 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/box2d_2.4.1-4/box2d-2.4.1.tar.gz +wrapdb_version = 2.4.1-4 + +[provide] +box2d = box2d_dep diff --git a/11-lightmaps/wraps/fmt.wrap b/11-lightmaps/wraps/fmt.wrap new file mode 100644 index 0000000..fd50847 --- /dev/null +++ b/11-lightmaps/wraps/fmt.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = fmt-11.0.2 +source_url = https://github.com/fmtlib/fmt/archive/11.0.2.tar.gz +source_filename = fmt-11.0.2.tar.gz +source_hash = 6cb1e6d37bdcb756dbbe59be438790db409cdb4868c66e888d5df9f13f7c027f +patch_filename = fmt_11.0.2-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/fmt_11.0.2-1/get_patch +patch_hash = 90c9e3b8e8f29713d40ca949f6f93ad115d78d7fb921064112bc6179e6427c5e +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/fmt_11.0.2-1/fmt-11.0.2.tar.gz +wrapdb_version = 11.0.2-1 + +[provide] +fmt = fmt_dep diff --git a/11-lightmaps/wraps/fuc2.wrap b/11-lightmaps/wraps/fuc2.wrap new file mode 100644 index 0000000..dc4fa27 --- /dev/null +++ b/11-lightmaps/wraps/fuc2.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=fuc2-0.2.0 +url=https://lcthw.dev/cpp/fuc2.git +revision=HEAD +depth=1 +method=meson + +[provide] +fuc2 = fuc2_dep diff --git a/11-lightmaps/wraps/glfw.wrap b/11-lightmaps/wraps/glfw.wrap new file mode 100644 index 0000000..a408912 --- /dev/null +++ b/11-lightmaps/wraps/glfw.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glfw-3.4 +source_url = https://github.com/glfw/glfw/archive/refs/tags/3.4.tar.gz +source_filename = glfw-3.4.tar.gz +source_hash = c038d34200234d071fae9345bc455e4a8f2f544ab60150765d7704e08f3dac01 +patch_filename = glfw_3.4-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glfw_3.4-1/get_patch +patch_hash = 58a6a6cdb28195d7f7e6f5de85dff7044d378e49b46bf1d4a9b04c97ed93e6b0 +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glfw_3.4-1/glfw-3.4.tar.gz +wrapdb_version = 3.4-1 + +[provide] +glfw3 = glfw_dep diff --git a/11-lightmaps/wraps/glm.wrap b/11-lightmaps/wraps/glm.wrap new file mode 100644 index 0000000..d75571e --- /dev/null +++ b/11-lightmaps/wraps/glm.wrap @@ -0,0 +1,13 @@ +[wrap-file] +directory = glm-1.0.1 +source_url = https://github.com/g-truc/glm/archive/refs/tags/1.0.1.tar.gz +source_filename = glm-1.0.1.tar.gz +source_hash = 9f3174561fd26904b23f0db5e560971cbf9b3cbda0b280f04d5c379d03bf234c +patch_filename = glm_1.0.1-1_patch.zip +patch_url = https://wrapdb.mesonbuild.com/v2/glm_1.0.1-1/get_patch +patch_hash = 25679275e26bc4c36bb617d1b4a52197039402af828d2a4bf67b3c0260a5df6a +source_fallback_url = https://github.com/mesonbuild/wrapdb/releases/download/glm_1.0.1-1/glm-1.0.1.tar.gz +wrapdb_version = 1.0.1-1 + +[provide] +glm = glm_dep