├── GLAD.pdb ├── OPENGL32.LIB ├── OpenGL Quote Scene.sln ├── OpenGL Quote Scene.vcxproj ├── OpenGL Quote Scene.vcxproj.filters ├── OpenGL Quote Scene.vcxproj.user ├── README.md ├── STB_IMAGE.pdb ├── Source.cpp ├── assimp-vc140-mt.dll ├── assimp.lib ├── build_windows.sh ├── camera.h ├── filesystem.h ├── fonts ├── Antonio-Bold.ttf ├── Antonio-Light.ttf ├── Antonio-Regular.ttf ├── OCRAEXT.TTF └── SIL Open Font License.txt ├── freetype.lib ├── glad.c ├── glew32s.lib ├── glfw3.lib ├── root_directory.h ├── shader.h ├── specular.fs ├── specular.vs ├── text.fs ├── text.vs └── vc140.pdb /GLAD.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/GLAD.pdb -------------------------------------------------------------------------------- /OPENGL32.LIB: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/OPENGL32.LIB -------------------------------------------------------------------------------- /OpenGL Quote Scene.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 17 4 | VisualStudioVersion = 17.4.33122.133 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OpenGL Quote Scene", "OpenGL Quote Scene.vcxproj", "{B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Debug|x64.ActiveCfg = Debug|x64 17 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Debug|x64.Build.0 = Debug|x64 18 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Debug|x86.ActiveCfg = Debug|Win32 19 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Debug|x86.Build.0 = Debug|Win32 20 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Release|x64.ActiveCfg = Release|x64 21 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Release|x64.Build.0 = Release|x64 22 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Release|x86.ActiveCfg = Release|Win32 23 | {B4E5BF30-330B-4BEE-A2D8-18AF3E2EC2FF}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {0E8EAA08-1F4D-4055-A594-CEE93DF1D1E2} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /OpenGL Quote Scene.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 16.0 23 | Win32Proj 24 | {b4e5bf30-330b-4bee-a2d8-18af3e2ec2ff} 25 | OpenGLQuoteScene 26 | 10.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v143 33 | Unicode 34 | 35 | 36 | Application 37 | false 38 | v143 39 | true 40 | Unicode 41 | 42 | 43 | Application 44 | true 45 | v143 46 | Unicode 47 | 48 | 49 | Application 50 | false 51 | v143 52 | true 53 | Unicode 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | D:\Programming\cpp\repos\Resources\includes;$(IncludePath) 75 | D:\Programming\cpp\repos\Resources\lib;$(LibraryPath) 76 | 77 | 78 | D:\Programming\cpp\repos\Resources\includes;$(IncludePath) 79 | D:\Programming\cpp\repos\Resources\lib;$(LibraryPath) 80 | 81 | 82 | D:\Programming\cpp\repos\Resources\includes;$(IncludePath) 83 | D:\Programming\cpp\repos\Resources\lib;$(LibraryPath) 84 | 85 | 86 | D:\Programming\cpp\repos\Resources\includes;$(IncludePath) 87 | D:\Programming\cpp\repos\Resources\lib;$(LibraryPath) 88 | 89 | 90 | 91 | Level3 92 | true 93 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 94 | true 95 | stdcpp20 96 | 97 | 98 | Console 99 | true 100 | D:\Programming\cpp\repos\Resources\dlls;D:\Programming\cpp\repos\Resources\bin;%(AdditionalLibraryDirectories) 101 | freetype.lib; opengl32.lib;assimp.lib;glfw3.lib;%(AdditionalDependencies) 102 | 103 | 104 | 105 | 106 | Level3 107 | true 108 | true 109 | true 110 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 111 | true 112 | stdcpp20 113 | 114 | 115 | Console 116 | true 117 | true 118 | true 119 | D:\Programming\cpp\repos\Resources\dlls;D:\Programming\cpp\repos\Resources\bin;%(AdditionalLibraryDirectories) 120 | freetype.lib; opengl32.lib;assimp.lib;glfw3.lib;%(AdditionalDependencies) 121 | 122 | 123 | 124 | 125 | Level3 126 | true 127 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 128 | true 129 | stdcpp20 130 | 131 | 132 | Console 133 | true 134 | D:\Programming\cpp\repos\Resources\dlls;D:\Programming\cpp\repos\Resources\bin;%(AdditionalLibraryDirectories) 135 | freetype.lib; opengl32.lib;assimp.lib;glfw3.lib;%(AdditionalDependencies) 136 | 137 | 138 | 139 | 140 | Level3 141 | true 142 | true 143 | true 144 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 145 | true 146 | stdcpp20 147 | 148 | 149 | Console 150 | true 151 | true 152 | true 153 | D:\Programming\cpp\repos\Resources\dlls;D:\Programming\cpp\repos\Resources\bin;%(AdditionalLibraryDirectories) 154 | freetype.lib; opengl32.lib;assimp.lib;glfw3.lib;%(AdditionalDependencies) 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | -------------------------------------------------------------------------------- /OpenGL Quote Scene.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | Source Files 23 | 24 | 25 | Source Files 26 | 27 | 28 | Source Files 29 | 30 | 31 | 32 | 33 | Source Files 34 | 35 | 36 | Source Files 37 | 38 | 39 | Source Files 40 | 41 | 42 | Source Files 43 | 44 | 45 | Source Files 46 | 47 | 48 | Source Files 49 | 50 | 51 | Source Files 52 | 53 | 54 | Source Files 55 | 56 | 57 | Source Files 58 | 59 | 60 | 61 | 62 | Source Files 63 | 64 | 65 | Source Files 66 | 67 | 68 | Source Files 69 | 70 | 71 | Source Files 72 | 73 | 74 | Source Files 75 | 76 | 77 | 78 | 79 | Source Files 80 | 81 | 82 | Source Files 83 | 84 | 85 | -------------------------------------------------------------------------------- /OpenGL Quote Scene.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # OpenGL Text Tendering and Animation 2 | 3 | ## About the Project 4 | 5 | This program is an animation program designed to allow an interactive 3D environment for educational purposes. The text is rendered onto a 2D plane in the environment to add to the experience and deliver the message in a visually creative and interesting way. 6 | 7 | 8 |
9 |

Watch the video here.

10 |
11 | 12 |

13 | 14 |

15 | 16 | ## Getting Started 17 | 18 | 1. Clone this repo. Settings are Microsoft Visual Studio x64. 19 | 20 | 2. Modify solution properties, (all solutions) edit debug > VCC++ > add includes add libraries. 21 | 22 | 3. Go to linker and add additional libraries of config, dlls, bin, resources. 23 | go to properties > linker > input and add glfw3.lib, opengl32.lib, assimp.lib, and freetype.lib. 24 | 25 | 4. Go to project add all existing items to the project. 26 | 27 | 5. if filestystem.h warnings: 28 | after class FileSystem { 29 | enter: 30 | public: 31 | #pragma warning(disable: 4996) 32 | 33 | 6. if using stb_image, add the following define below all includes: 34 | #define STB_IMAGE_IMPLEMENTATION 35 | 36 | 7. (optional) Add additional helpful macros. See https://github.com/nothings/stb/blob/master/stb_image.h 37 | 38 | 8. Set the C++ language properties and add most recent C++ version to use the 2020 libraries. 39 | 40 | ## References 41 | 42 | Credit to LearnOpenGL for shaders, camera, glfw functions and text rendering functions. 43 | 44 | https://github.com/JoeyDeVries/LearnOpenGL/blob/master/LICENSE.md 45 | 46 | Learn OpenGL, extensive tutorial resource for learning Modern OpenGL. (n.d.-c). https://learnopengl.com/ 47 | 48 | 49 | ## XCode Usage 50 | 51 | Open a terminal in the project directory and run the code to remove the old build folder and generate a new one with the Xcode project file. 52 | 53 | ```bash 54 | mkdir build 55 | cd build 56 | cmake -G Xcode .. 57 | 58 | #Usage: when updating the build folder, remove it first then regenerate the folder as above 59 | rm -rf build 60 | ``` 61 | Set the working directory in Xcode using Product > Scheme > Edit Scheme > Run Debug > Options > Working Directory > (Check Set Custom) > Project directory/build. 62 | 63 | Build and run the project. 64 | 65 | ## License: 66 | 67 | The code is based on various tutorial code from LearnOpenGL.com. 68 | 69 | Tutorial code is © Joey DeVries and licensed under the CC BY 4.0 License. 70 | 71 | Modifications and additional contributions are © Shera Adams and licensed under the Apache 2.0 License. 72 | 73 | Proudly crafted with ❤️ by Shera Adams. 74 | -------------------------------------------------------------------------------- /STB_IMAGE.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/STB_IMAGE.pdb -------------------------------------------------------------------------------- /Source.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include FT_FREETYPE_H 9 | #include "filesystem.h" 10 | #include"camera.h" 11 | #include"shader.h" 12 | #include 13 | #include 14 | #include 15 | #include 16 | #define STB_IMAGE_IMPLEMENTATION 17 | // functions 18 | void framebuffer_size_callback(GLFWwindow* window, int width, int height); 19 | void mouse_callback(GLFWwindow* window, double xpos, double ypos); 20 | void scroll_callback(GLFWwindow* window, double xoffset, double yoffset); 21 | void processInput(GLFWwindow* window); 22 | void renderSphere(); 23 | unsigned int loadTexture(const char* path); 24 | unsigned int loadCubemap(std::vector faces); 25 | void GetDesktopResolution(float& horizontal, float& vertical); 26 | void RenderText(Shader& shader, std::string text, float x, float y, float scale, glm::vec3 color); 27 | 28 | // constants and variables 29 | float SCR_WIDTH = 900; 30 | float SCR_HEIGHT = 700; 31 | unsigned int VAO, VBO; 32 | int nrRows = 1; 33 | int nrColumns = 1; 34 | float spacing = 1; 35 | float speed = .1f; 36 | GLfloat rotateY = 0.0f; 37 | GLfloat rotateX = 0.0f; 38 | 39 | Camera camera(glm::vec3(0.0f, 0.0f, 3.0f)); 40 | float lastX = SCR_WIDTH / 2.0f; 41 | float lastY = SCR_HEIGHT / 2.0f; 42 | bool firstMouse = true; 43 | float deltaTime = 0.0f; 44 | float lastFrame = 0.0f; 45 | 46 | glm::vec3 lightPos(1.2f, 1.0f, 2.0f); 47 | glm::vec3 point = glm::vec3(0.0f, 0.0f, 0.0f); 48 | 49 | 50 | struct Character 51 | { 52 | unsigned int TextureID; // ID handle of the glyph texture 53 | glm::ivec2 Size; // Size of glyph 54 | glm::ivec2 Bearing; // Offset from baseline to left/top of glyph 55 | unsigned int Advance; // Horizontal offset to advance to next glyph 56 | }; 57 | 58 | std::map Characters; 59 | 60 | 61 | int main() 62 | { 63 | GetDesktopResolution(SCR_WIDTH, SCR_HEIGHT); 64 | glfwInit(); 65 | glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); 66 | glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); 67 | glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); 68 | 69 | #ifdef __APPLE__ 70 | glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); 71 | #endif 72 | 73 | GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "Quote of the Day", NULL, NULL); 74 | if (window == NULL) 75 | { 76 | std::cout << "Failed to create GLFW window" << std::endl; 77 | glfwTerminate(); 78 | return -1; 79 | } 80 | glfwMakeContextCurrent(window); 81 | glfwSetFramebufferSizeCallback(window, framebuffer_size_callback); 82 | glfwSetCursorPosCallback(window, mouse_callback); 83 | glfwSetScrollCallback(window, scroll_callback); 84 | 85 | glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); 86 | 87 | if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) 88 | { 89 | std::cout << "Failed to initialize GLAD" << std::endl; 90 | return -1; 91 | } 92 | 93 | FT_Library ft; 94 | if (FT_Init_FreeType(&ft)) 95 | { 96 | std::cout << "ERROR::FREETYPE: Could not init FreeType Library" << std::endl; 97 | return -1; 98 | } 99 | 100 | std::string font_name = FileSystem::getPath("resources/fonts/Antonio-Bold.ttf"); 101 | if (font_name.empty()) 102 | { 103 | std::cout << "ERROR::FREETYPE: Failed to load font_name" << std::endl; 104 | return -1; 105 | } 106 | 107 | FT_Face face; 108 | if (FT_New_Face(ft, font_name.c_str(), 0, &face)) { 109 | std::cout << "ERROR::FREETYPE: Failed to load font" << std::endl; 110 | return -1; 111 | } 112 | else { 113 | 114 | FT_Set_Pixel_Sizes(face, 0, 48); 115 | 116 | 117 | glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 118 | 119 | for (unsigned char c = 0; c < 128; c++) 120 | { 121 | if (FT_Load_Char(face, c, FT_LOAD_RENDER)) 122 | { 123 | std::cout << "ERROR::FREETYTPE: Failed to load Glyph" << std::endl; 124 | continue; 125 | } 126 | unsigned int texture; 127 | glGenTextures(1, &texture); 128 | glBindTexture(GL_TEXTURE_2D, texture); 129 | glTexImage2D( 130 | GL_TEXTURE_2D, 131 | 0, 132 | GL_RED, 133 | face->glyph->bitmap.width, 134 | face->glyph->bitmap.rows, 135 | 0, 136 | GL_RED, 137 | GL_UNSIGNED_BYTE, 138 | face->glyph->bitmap.buffer 139 | ); 140 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 141 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 142 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 143 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 144 | Character character = { 145 | texture, 146 | glm::ivec2(face->glyph->bitmap.width, face->glyph->bitmap.rows), 147 | glm::ivec2(face->glyph->bitmap_left, face->glyph->bitmap_top), 148 | static_cast(face->glyph->advance.x) 149 | }; 150 | Characters.insert(std::pair(c, character)); 151 | } 152 | glBindTexture(GL_TEXTURE_2D, 0); 153 | } 154 | FT_Done_Face(face); 155 | FT_Done_FreeType(ft); 156 | 157 | glEnable(GL_DEPTH_TEST); 158 | glEnable(GL_MULTISAMPLE); 159 | // ** Text Rendering **// 160 | 161 | glEnable(GL_BLEND); 162 | glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 163 | 164 | // init shaders 165 | Shader specShader("specular.vs", "specular.fs"); 166 | Shader shader("text.vs", "text.fs"); 167 | 168 | 169 | glm::mat4 projection = glm::ortho(0.0f, static_cast(SCR_WIDTH), 0.0f, static_cast(SCR_HEIGHT)); 170 | 171 | shader.use(); 172 | 173 | glUniformMatrix4fv(glGetUniformLocation(shader.ID, "projection"), 1, GL_FALSE, glm::value_ptr(projection)); 174 | 175 | glm::vec3 pointLightPositions[] = { 176 | glm::vec3(2.0f, 1.0f, 2.0f), 177 | glm::vec3(1.0f, 2.0f, -3.0f), 178 | glm::vec3(-3.0f, 1.0f, -2.0f), 179 | glm::vec3(1.0f, 1.0f, 2.0f), 180 | glm::vec3(-0.0f, 2.0f, -2.0f), 181 | glm::vec3(2.0f, 2.0f, 3.0f), 182 | glm::vec3(0.0f, 3.0f, -2.0f), 183 | glm::vec3(-2.0f, 1.0f, -2.0f), 184 | glm::vec3(1.0f, 2.0f, -3.0f), 185 | glm::vec3(2.0f, 1.0f, 2.0f), 186 | glm::vec3(3.0f, 1.0f, 0.0f), 187 | glm::vec3(2.0f, 1.0f, 2.0f), 188 | glm::vec3(2.0f, 1.0f, -2.0f), 189 | glm::vec3(-1.0f, 2.0f, 2.0f), 190 | glm::vec3(2.0f, 1.0f, 2.0f), 191 | glm::vec3(3.0f, 3.0f, -5.0f), 192 | glm::vec3(0.0f, 2.0f, 2.0f), 193 | glm::vec3(2.0f, 2.0f, 3.0f), 194 | }; 195 | 196 | //TEXT VBO VAO 197 | glGenVertexArrays(1, &VAO); 198 | glGenBuffers(1, &VBO); 199 | glBindVertexArray(VAO); 200 | glBindBuffer(GL_ARRAY_BUFFER, VBO); 201 | glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 6 * 4, NULL, GL_DYNAMIC_DRAW); 202 | glEnableVertexAttribArray(0); 203 | glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0); 204 | glBindBuffer(GL_ARRAY_BUFFER, 0); 205 | glBindVertexArray(0); 206 | 207 | unsigned int diffuseeffect = loadTexture("resources/textures/space/color.png"); 208 | unsigned int speculareffect = loadTexture("resources/textures/space/dwarf.png"); 209 | unsigned int sphereTexture = loadTexture("resources/textures/space/10.jpg"); 210 | unsigned int sphere2Texture = loadTexture("resources/textures/space/35.jpg"); 211 | unsigned int sphere4Texture = loadTexture("resources/textures/space/36.jpg"); 212 | unsigned int sphere5Texture = loadTexture("resources/textures/space/blue.jpg"); 213 | unsigned int sphere6Texture = loadTexture("resources/textures/space/glitter.jpg"); 214 | unsigned int sphere3Texture = loadTexture("resources/textures/space/34.jpg"); 215 | 216 | 217 | std::vector faces 218 | { 219 | "resources/textures/skybox2/right.png", // right or rightright 220 | "resources/textures/skybox2/left.png",//left or left 221 | "resources/textures/skybox2/top.png", //top 222 | "resources/textures/skybox2/bottom.png", //bottom 223 | "resources/textures/skybox2/front.png", //front or right 224 | "resources/textures/skybox2/back.png", //back or leftleft 225 | }; 226 | 227 | unsigned int cubemapTexture = loadCubemap(faces); 228 | shader.use(); 229 | shader.setInt("texture1", 0); 230 | specShader.use(); 231 | specShader.setInt("material.diffuse", 0); 232 | specShader.setInt("material.specular", 1); 233 | 234 | // render while loop 235 | while (!glfwWindowShouldClose(window)) 236 | { 237 | float currentFrame = static_cast(glfwGetTime()); 238 | deltaTime = currentFrame - lastFrame; 239 | lastFrame = currentFrame; 240 | 241 | 242 | // ** TEXT REND **// 243 | processInput(window); 244 | glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED); 245 | // ** TEXT REND **// 246 | 247 | glClearColor(0.1f, 0.1f, 0.1f, 1.0f); 248 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 249 | 250 | // define world 251 | glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f); 252 | glm::mat4 view = camera.GetViewMatrix(); 253 | glm::mat4 model = glm::mat4(1.0f); 254 | 255 | 256 | 257 | // init shader 258 | specShader.use(); 259 | specShader.setMat4("projection", projection); 260 | specShader.setMat4("view", view); 261 | // init shader 262 | specShader.setVec3("viewPos", camera.Position); 263 | specShader.setFloat("material.shininess", 32.0f); 264 | // directional light 265 | specShader.setVec3("dirLight.direction", -0.2f, -1.0f, -0.3f); 266 | specShader.setVec3("dirLight.ambient", 0.05f, 0.05f, 0.05f); 267 | specShader.setVec3("dirLight.diffuse", 0.4f, 0.4f, 0.4f); 268 | specShader.setVec3("dirLight.specular", 0.5f, 0.5f, 0.5f); 269 | // point light 1 270 | specShader.setVec3("pointLights[0].position", pointLightPositions[0]); 271 | specShader.setVec3("pointLights[0].ambient", 0.05f, 0.05f, 0.05f); 272 | specShader.setVec3("pointLights[0].diffuse", 0.8f, 0.8f, 0.8f); 273 | specShader.setVec3("pointLights[0].specular", 1.0f, 1.0f, 1.0f); 274 | specShader.setFloat("pointLights[0].constant", 1.0f); 275 | specShader.setFloat("pointLights[0].linear", 0.09f); 276 | specShader.setFloat("pointLights[0].quadratic", 0.032f); 277 | // point light 2 278 | specShader.setVec3("pointLights[1].position", pointLightPositions[1]); 279 | specShader.setVec3("pointLights[1].ambient", 0.05f, 0.05f, 0.05f); 280 | specShader.setVec3("pointLights[1].diffuse", 0.8f, 0.8f, 0.8f); 281 | specShader.setVec3("pointLights[1].specular", 1.0f, 1.0f, 1.0f); 282 | specShader.setFloat("pointLights[1].constant", 1.0f); 283 | specShader.setFloat("pointLights[1].linear", 0.09f); 284 | specShader.setFloat("pointLights[1].quadratic", 0.032f); 285 | // point light 3 286 | specShader.setVec3("pointLights[2].position", pointLightPositions[2]); 287 | specShader.setVec3("pointLights[2].ambient", 0.05f, 0.05f, 0.05f); 288 | specShader.setVec3("pointLights[2].diffuse", 0.8f, 0.8f, 0.8f); 289 | specShader.setVec3("pointLights[2].specular", 1.0f, 1.0f, 1.0f); 290 | specShader.setFloat("pointLights[2].constant", 1.0f); 291 | specShader.setFloat("pointLights[2].linear", 0.09f); 292 | specShader.setFloat("pointLights[2].quadratic", 0.032f); 293 | // point light 4 294 | specShader.setVec3("pointLights[3].position", pointLightPositions[3]); 295 | specShader.setVec3("pointLights[3].ambient", 0.05f, 0.05f, 0.05f); 296 | specShader.setVec3("pointLights[3].diffuse", 0.8f, 0.8f, 0.8f); 297 | specShader.setVec3("pointLights[3].specular", 1.0f, 1.0f, 1.0f); 298 | specShader.setFloat("pointLights[3].constant", 1.0f); 299 | specShader.setFloat("pointLights[3].linear", 0.09f); 300 | specShader.setFloat("pointLights[3].quadratic", 0.032f); 301 | // spotLight 302 | specShader.setVec3("spotLight.position", camera.Position); 303 | specShader.setVec3("spotLight.direction", camera.Front); 304 | specShader.setVec3("spotLight.ambient", 0.0f, 0.0f, 0.0f); 305 | specShader.setVec3("spotLight.diffuse", 1.0f, 1.0f, 1.0f); 306 | specShader.setVec3("spotLight.specular", 1.0f, 1.0f, 1.0f); 307 | specShader.setFloat("spotLight.constant", 1.0f); 308 | specShader.setFloat("spotLight.linear", 0.09f); 309 | specShader.setFloat("spotLight.quadratic", 0.032f); 310 | specShader.setFloat("spotLight.cutOff", glm::cos(glm::radians(12.5f))); 311 | specShader.setFloat("spotLight.outerCutOff", glm::cos(glm::radians(15.0f))); 312 | 313 | // init textures 314 | glActiveTexture(GL_TEXTURE0); 315 | glBindTexture(GL_TEXTURE_2D, diffuseeffect); 316 | glActiveTexture(GL_TEXTURE1); 317 | glBindTexture(GL_TEXTURE_2D, speculareffect); 318 | 319 | model = glm::mat4(1.0f); 320 | for (int row = 0; row < nrRows; ++row) 321 | { 322 | specShader.setFloat("metallic", (float)row / (float)nrRows); 323 | for (int col = 0; col < nrColumns; ++col) 324 | { 325 | // we clamp the roughness to 0.025 - 1.0 as perfectly smooth surfaces (roughness of 0.0) tend to look a bit off 326 | // on direct lighting. 327 | specShader.setFloat("roughness", glm::clamp((float)col / (float)nrColumns, 0.05f, 1.0f)); 328 | 329 | model = glm::mat4(1.0f); 330 | model = glm::translate(model, glm::vec3( 331 | (float)(col - (nrColumns / 2)) * spacing, 332 | (float)(row - (nrRows / 2)) * spacing, 333 | -2.0f 334 | )); 335 | 336 | float xx = sin(glfwGetTime() * speed * 0.55f) * 100.0f * 4.0f * 1.3f; 337 | float zz = cos(glfwGetTime() * speed * 0.55f) * 100.0f * 4.0f * 1.3f; 338 | glActiveTexture(GL_TEXTURE0); 339 | glBindTexture(GL_TEXTURE_2D, sphereTexture); 340 | model = glm::translate(model, point); 341 | model = glm::rotate(model, glm::radians(rotateY), glm::vec3(1.0f, -1.0f, -13.0f)); 342 | model = glm::rotate(model, glm::radians(rotateX), glm::vec3(0.0f, 0.0f, -1.0f)); 343 | // model_earth = glm::translate(model_earth, glm::vec3(xx, 0.0f, zz)); 344 | glm::vec3 xpoint = glm::vec3(xx, 0.0f, zz); 345 | model = glm::rotate(model, glm::radians(-90.0f), glm::vec3(1.0f, 0.0f, 0.f)); 346 | model = glm::rotate(model, glm::radians(-33.25f), glm::vec3(0.0f, 1.0f, 0.f)); 347 | model = glm::rotate(model, (GLfloat)glfwGetTime() * glm::radians(-33.25f) * 2.0f, glm::vec3(0.0f, 0.0f, 1.f)); 348 | specShader.setMat4("model", model); 349 | renderSphere(); 350 | } 351 | } 352 | 353 | glActiveTexture(GL_TEXTURE0); 354 | model = glm::mat4(1.0f); 355 | for (int row = 0; row < nrRows; ++row) 356 | { 357 | specShader.setFloat("metallic", (float)row / (float)nrRows); 358 | for (int col = 0; col < nrColumns; ++col) 359 | { 360 | specShader.setFloat("roughness", glm::clamp((float)col / (float)nrColumns, 0.05f, 1.0f)); 361 | model = glm::mat4(1.0f); 362 | model = glm::translate(model, glm::vec3( 363 | (float)(col - (nrColumns / 2)) * spacing, 364 | (float)(row - (nrRows / 2)) * spacing, 365 | -2.0f 366 | )); 367 | float xx = sin(glfwGetTime() * speed * 0.55f) * -100.0f * 4.0f * 1.3f; 368 | float zz = cos(glfwGetTime() * speed * 0.55f) * 100.0f * 4.0f * 1.3f; 369 | glActiveTexture(GL_TEXTURE0); 370 | glBindTexture(GL_TEXTURE_2D, sphere2Texture); 371 | model = glm::translate(model, point); 372 | model = glm::rotate(model, glm::radians(rotateY), glm::vec3(1.0f, -1.0f, -13.0f)); 373 | model = glm::rotate(model, glm::radians(rotateX), glm::vec3(0.0f, 0.0f, -1.0f)); 374 | // model_earth = glm::translate(model_earth, glm::vec3(xx, 0.0f, zz)); 375 | glm::vec3 xpoint = glm::vec3(xx, 0.0f, zz); 376 | model = glm::rotate(model, glm::radians(-20.0f), glm::vec3(1.0f, 0.0f, 0.f)); 377 | model = glm::rotate(model, glm::radians(33.25f), glm::vec3(0.0f, 1.0f, 0.f)); 378 | model = glm::rotate(model, (GLfloat)glfwGetTime() * glm::radians(-33.25f) * 2.0f, glm::vec3(0.0f, 0.0f, 1.f)); 379 | specShader.setMat4("model", model); 380 | unsigned int sphereVAO = 0; 381 | unsigned int indexCount; 382 | renderSphere(); 383 | } 384 | } 385 | 386 | glActiveTexture(GL_TEXTURE1); 387 | glBindTexture(GL_TEXTURE_2D, sphere3Texture); 388 | model = glm::mat4(1.0f); 389 | for (int row = 0; row < nrRows; ++row) 390 | { 391 | specShader.setFloat("metallic", (float)row / (float)nrRows); 392 | for (int col = 0; col < nrColumns; ++col) 393 | { 394 | specShader.setFloat("roughness", glm::clamp((float)col / (float)nrColumns, 0.05f, 1.0f)); 395 | model = glm::mat4(1.0f); 396 | model = glm::translate(model, glm::vec3( 397 | (float)(col - (nrColumns / 2)) * spacing, 398 | (float)(row - (nrRows / 2)) * spacing, 399 | -2.0f 400 | )); 401 | 402 | float xx = sin(glfwGetTime() * speed * 0.55f) * -100.0f * 4.0f * 1.3f; 403 | float zz = cos(glfwGetTime() * speed * 0.55f) * 100.0f * 4.0f * 1.3f; 404 | glActiveTexture(GL_TEXTURE0); 405 | glBindTexture(GL_TEXTURE_2D, sphere3Texture); 406 | model = glm::translate(model, point); 407 | model = glm::rotate(model, glm::radians(rotateY), glm::vec3(1.0f, -1.0f, -13.0f)); 408 | model = glm::rotate(model, glm::radians(rotateX), glm::vec3(0.0f, 0.0f, -1.0f)); 409 | // model_earth = glm::translate(model_earth, glm::vec3(xx, 0.0f, zz)); 410 | glm::vec3 xpoint = glm::vec3(xx, 0.0f, zz); 411 | model = glm::rotate(model, glm::radians(-120.0f), glm::vec3(1.0f, 0.0f, 0.f)); 412 | model = glm::rotate(model, glm::radians(-23.25f), glm::vec3(0.0f, 1.0f, 0.f)); 413 | model = glm::rotate(model, (GLfloat)glfwGetTime() * glm::radians(-33.25f) * 2.0f, glm::vec3(0.0f, 0.0f, 1.f)); 414 | specShader.setMat4("model", model); 415 | unsigned int sphereVAO = 0; 416 | unsigned int indexCount; 417 | renderSphere(); 418 | } 419 | } 420 | glActiveTexture(GL_TEXTURE1); 421 | glBindTexture(GL_TEXTURE_2D, sphere3Texture); 422 | model = glm::mat4(1.0f); 423 | for (int row = 0; row < nrRows; ++row) 424 | { 425 | specShader.setFloat("metallic", (float)row / (float)nrRows); 426 | for (int col = 0; col < nrColumns; ++col) 427 | { 428 | specShader.setFloat("roughness", glm::clamp((float)col / (float)nrColumns, 0.05f, 1.0f)); 429 | model = glm::mat4(1.0f); 430 | model = glm::translate(model, glm::vec3( 431 | (float)(col - (nrColumns / 2)) * spacing, 432 | (float)(row - (nrRows / 2)) * spacing, 433 | -2.0f 434 | )); 435 | 436 | float xx = sin(glfwGetTime() * speed * 0.55f) * -100.0f * 4.0f * 1.3f; 437 | float zz = cos(glfwGetTime() * speed * 0.55f) * 100.0f * 4.0f * 1.3f; 438 | glActiveTexture(GL_TEXTURE0); 439 | glBindTexture(GL_TEXTURE_2D, sphere4Texture); 440 | model = glm::translate(model, point); 441 | model = glm::rotate(model, glm::radians(rotateY), glm::vec3(1.0f, -1.0f, -13.0f)); 442 | model = glm::rotate(model, glm::radians(rotateX), glm::vec3(0.0f, 0.0f, -1.0f)); 443 | // model_earth = glm::translate(model_earth, glm::vec3(xx, 0.0f, zz)); 444 | glm::vec3 xpoint = glm::vec3(xx, 0.0f, zz); 445 | model = glm::rotate(model, glm::radians(120.0f), glm::vec3(1.0f, 0.0f, 0.f)); 446 | model = glm::rotate(model, glm::radians(60.25f), glm::vec3(0.0f, 1.0f, 0.f)); 447 | model = glm::rotate(model, (GLfloat)glfwGetTime() * glm::radians(-33.25f) * 2.0f, glm::vec3(0.0f, 0.0f, 1.f)); 448 | specShader.setMat4("model", model); 449 | unsigned int sphereVAO = 0; 450 | unsigned int indexCount; 451 | renderSphere(); 452 | } 453 | } 454 | 455 | glActiveTexture(GL_TEXTURE1); 456 | glBindTexture(GL_TEXTURE_2D, sphere3Texture); 457 | model = glm::mat4(1.0f); 458 | for (int row = 0; row < nrRows; ++row) 459 | { 460 | specShader.setFloat("metallic", (float)row / (float)nrRows); 461 | for (int col = 0; col < nrColumns; ++col) 462 | { 463 | specShader.setFloat("roughness", glm::clamp((float)col / (float)nrColumns, 0.05f, 1.0f)); 464 | model = glm::mat4(1.0f); 465 | model = glm::translate(model, glm::vec3( 466 | (float)(col - (nrColumns / 2)) * spacing, 467 | (float)(row - (nrRows / 2)) * spacing, 468 | -2.0f 469 | )); 470 | 471 | float xx = sin(glfwGetTime() * speed * 0.55f) * -50.0f * 4.0f * 1.3f; 472 | float zz = cos(glfwGetTime() * speed * 0.55f) * 100.0f * 4.0f * 1.3f; 473 | glActiveTexture(GL_TEXTURE0); 474 | glBindTexture(GL_TEXTURE_2D, sphere5Texture); 475 | model = glm::translate(model, point); 476 | model = glm::rotate(model, glm::radians(rotateY), glm::vec3(1.0f, -1.0f, -13.0f)); 477 | model = glm::rotate(model, glm::radians(rotateX), glm::vec3(0.0f, 0.0f, -1.0f)); 478 | // model_earth = glm::translate(model_earth, glm::vec3(xx, 0.0f, zz)); 479 | glm::vec3 xpoint = glm::vec3(xx, 0.0f, zz); 480 | model = glm::rotate(model, glm::radians(-20.0f), glm::vec3(1.0f, 0.0f, 0.f)); 481 | model = glm::rotate(model, glm::radians(80.25f), glm::vec3(0.0f, 1.0f, 0.f)); 482 | model = glm::rotate(model, (GLfloat)glfwGetTime() * glm::radians(-33.25f) * 2.0f, glm::vec3(0.0f, 0.0f, 1.f)); 483 | specShader.setMat4("model", model); 484 | unsigned int sphereVAO = 0; 485 | unsigned int indexCount; 486 | renderSphere(); 487 | } 488 | } 489 | 490 | glActiveTexture(GL_TEXTURE1); 491 | glBindTexture(GL_TEXTURE_2D, sphere3Texture); 492 | model = glm::mat4(1.0f); 493 | for (int row = 0; row < nrRows; ++row) 494 | { 495 | specShader.setFloat("metallic", (float)row / (float)nrRows); 496 | for (int col = 0; col < nrColumns; ++col) 497 | { 498 | specShader.setFloat("roughness", glm::clamp((float)col / (float)nrColumns, 0.05f, 1.0f)); 499 | model = glm::mat4(1.0f); 500 | model = glm::translate(model, glm::vec3( 501 | (float)(col - (nrColumns / 2)) * spacing, 502 | (float)(row - (nrRows / 2)) * spacing, 503 | -2.0f 504 | )); 505 | 506 | float xx = sin(glfwGetTime() * speed * 0.55f) * -100.0f * 4.0f * 1.3f; 507 | float zz = cos(glfwGetTime() * speed * 0.55f) * 50.0f * 4.0f * 1.3f; 508 | glActiveTexture(GL_TEXTURE0); 509 | glBindTexture(GL_TEXTURE_2D, sphere6Texture); 510 | model = glm::translate(model, point); 511 | model = glm::rotate(model, glm::radians(rotateY), glm::vec3(1.0f, -1.0f, -13.0f)); 512 | model = glm::rotate(model, glm::radians(rotateX), glm::vec3(0.0f, 0.0f, -1.0f)); 513 | // model_earth = glm::translate(model_earth, glm::vec3(xx, 0.0f, zz)); 514 | glm::vec3 xpoint = glm::vec3(xx, 0.0f, zz); 515 | model = glm::rotate(model, glm::radians(0.0f), glm::vec3(1.0f, 0.0f, 0.f)); 516 | model = glm::rotate(model, glm::radians(10.25f), glm::vec3(0.0f, 1.0f, 0.f)); 517 | model = glm::rotate(model, (GLfloat)glfwGetTime() * glm::radians(-33.25f) * 2.0f, glm::vec3(0.0f, 0.0f, 1.f)); 518 | specShader.setMat4("model", model); 519 | unsigned int sphereVAO = 0; 520 | unsigned int indexCount; 521 | renderSphere(); 522 | } 523 | } 524 | 525 | shader.setMat4("model", model); 526 | model = glm::mat4(1.0f); 527 | for (int row = 0; row < nrRows; ++row) 528 | { 529 | for (int col = 0; col < nrColumns; ++col) 530 | { 531 | model = glm::mat4(1.0f); 532 | model = glm::translate(model, glm::vec3( 533 | (float)(col - (nrColumns / 2)) * spacing, 534 | (float)(row - (nrRows / 2)) * spacing, 535 | -2.0f 536 | )); 537 | float xx = sin(glfwGetTime() * speed * 0.55f) * -100.0f * 4.0f * 1.3f; 538 | float zz = cos(glfwGetTime() * speed * 0.55f) * 100.0f * 4.0f * 1.3f; 539 | glActiveTexture(GL_TEXTURE0); 540 | glBindTexture(GL_TEXTURE_2D, sphere2Texture); 541 | model = glm::translate(model, point); 542 | model = glm::rotate(model, glm::radians(rotateY), glm::vec3(1.0f, -1.0f, -13.0f)); 543 | model = glm::rotate(model, glm::radians(rotateX), glm::vec3(0.0f, 0.0f, -1.0f)); 544 | // model_earth = glm::translate(model_earth, glm::vec3(xx, 0.0f, zz)); 545 | glm::vec3 xpoint = glm::vec3(xx, 0.0f, zz); 546 | model = glm::rotate(model, glm::radians(-20.0f), glm::vec3(1.0f, 0.0f, 0.f)); 547 | model = glm::rotate(model, glm::radians(33.25f), glm::vec3(0.0f, 1.0f, 0.f)); 548 | model = glm::rotate(model, (GLfloat)glfwGetTime() * glm::radians(-33.25f) * 2.0f, glm::vec3(0.0f, 0.0f, 1.f)); 549 | shader.setMat4("model", model); 550 | RenderText(shader, "- Ralph Waldo Emerson", 180.0f, 125.0f, 1.4f, glm::vec3(0.5, 0.8f, 0.2f)); 551 | RenderText(shader, "\"To be yourself in a world that is constantly trying", 720.0f, 950.0f, 1.1f, glm::vec3(0.3, 0.7f, 0.9f)); // vec 1 is position x, y and size, last vec is color 552 | RenderText(shader, "to make you something else is the greatest accomplishment.\"", 600.0f, 870.0f, 1.1f, glm::vec3(0.5, 0.4f, 0.9f)); 553 | } 554 | } 555 | 556 | glfwSwapBuffers(window); 557 | glfwPollEvents(); 558 | } 559 | 560 | glDeleteVertexArrays(1, &VAO); 561 | glDeleteBuffers(1, &VBO); 562 | glfwTerminate(); 563 | return 0; 564 | } 565 | 566 | void processInput(GLFWwindow* window) 567 | { 568 | if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) 569 | glfwSetWindowShouldClose(window, true); 570 | 571 | if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) 572 | camera.ProcessKeyboard(FORWARD, deltaTime); 573 | if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) 574 | camera.ProcessKeyboard(BACKWARD, deltaTime); 575 | if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) 576 | camera.ProcessKeyboard(LEFT, deltaTime); 577 | if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) 578 | camera.ProcessKeyboard(RIGHT, deltaTime); 579 | } 580 | 581 | void framebuffer_size_callback(GLFWwindow* window, int width, int height) 582 | { 583 | glViewport(0, 0, width, height); 584 | } 585 | 586 | void mouse_callback(GLFWwindow* window, double xposIn, double yposIn) 587 | { 588 | float xpos = static_cast(xposIn); 589 | float ypos = static_cast(yposIn); 590 | 591 | if (firstMouse) 592 | { 593 | lastX = xpos; 594 | lastY = ypos; 595 | firstMouse = false; 596 | } 597 | 598 | float xoffset = xpos - lastX; 599 | float yoffset = lastY - ypos; // reversed since y-coordinates go from bottom to top 600 | 601 | lastX = xpos; 602 | lastY = ypos; 603 | 604 | camera.ProcessMouseMovement(xoffset, yoffset); 605 | } 606 | 607 | 608 | void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) 609 | { 610 | camera.ProcessMouseScroll(static_cast(yoffset)); 611 | } 612 | 613 | 614 | unsigned int sphereVAO = 0; 615 | unsigned int indexCount; 616 | void renderSphere() 617 | { 618 | if (sphereVAO == 0) 619 | { 620 | glGenVertexArrays(1, &sphereVAO); 621 | unsigned int vbo, ebo; 622 | glGenBuffers(1, &vbo); 623 | glGenBuffers(1, &ebo); 624 | std::vector positions; 625 | std::vector uv; 626 | std::vector normals; 627 | std::vector indices; 628 | const unsigned int X_SEGMENTS = 64; 629 | const unsigned int Y_SEGMENTS = 64; 630 | const float PI = 3.14159265359f; 631 | for (unsigned int x = 0; x <= X_SEGMENTS; ++x) 632 | { 633 | for (unsigned int y = 0; y <= Y_SEGMENTS; ++y) 634 | { 635 | float xSegment = (float)x / (float)X_SEGMENTS; 636 | float ySegment = (float)y / (float)Y_SEGMENTS; 637 | float xPos = std::cos(xSegment * 2.0f * PI) * std::sin(ySegment * PI)*.45 + 0; 638 | float yPos = std::cos(ySegment * PI) * .45 + 2.7; 639 | float zPos = std::sin(xSegment * 2.0f * PI) * std::sin(ySegment * PI)*.45 + .25; 640 | 641 | positions.push_back(glm::vec3(xPos, yPos, zPos)); 642 | uv.push_back(glm::vec2(xSegment, ySegment)); 643 | normals.push_back(glm::vec3(xPos, yPos, zPos)); 644 | } 645 | } 646 | 647 | bool oddRow = false; 648 | for (unsigned int y = 0; y < Y_SEGMENTS; ++y) 649 | { 650 | if (!oddRow) // even rows: y == 0, y == 2; and so on 651 | { 652 | for (unsigned int x = 0; x <= X_SEGMENTS; ++x) 653 | { 654 | indices.push_back(y * (X_SEGMENTS + 1) + x); 655 | indices.push_back((y + 1) * (X_SEGMENTS + 1) + x); 656 | } 657 | } 658 | else 659 | { 660 | for (int x = X_SEGMENTS; x >= 0; --x) 661 | { 662 | indices.push_back((y + 1) * (X_SEGMENTS + 1) + x); 663 | indices.push_back(y * (X_SEGMENTS + 1) + x); 664 | } 665 | } 666 | oddRow = !oddRow; 667 | } 668 | indexCount = static_cast(indices.size()); 669 | 670 | std::vector data; 671 | for (unsigned int i = 0; i < positions.size(); ++i) 672 | { 673 | data.push_back(positions[i].x); 674 | data.push_back(positions[i].y); 675 | data.push_back(positions[i].z); 676 | if (normals.size() > 0) 677 | { 678 | data.push_back(normals[i].x); 679 | data.push_back(normals[i].y); 680 | data.push_back(normals[i].z); 681 | } 682 | if (uv.size() > 0) 683 | { 684 | data.push_back(uv[i].x); 685 | data.push_back(uv[i].y); 686 | } 687 | } 688 | glBindVertexArray(sphereVAO); 689 | glBindBuffer(GL_ARRAY_BUFFER, vbo); 690 | glBufferData(GL_ARRAY_BUFFER, data.size() * sizeof(float), &data[0], GL_STATIC_DRAW); 691 | glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); 692 | glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW); 693 | unsigned int stride = (3 + 2 + 3) * sizeof(float); 694 | glEnableVertexAttribArray(0); 695 | glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, stride, (void*)0); 696 | glEnableVertexAttribArray(1); 697 | glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, stride, (void*)(3 * sizeof(float))); 698 | glEnableVertexAttribArray(2); 699 | glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, stride, (void*)(6 * sizeof(float))); 700 | } 701 | 702 | glBindVertexArray(sphereVAO); 703 | glDrawElements(GL_TRIANGLE_STRIP, indexCount, GL_UNSIGNED_INT, 0); 704 | } 705 | 706 | unsigned int loadCubemap(std::vector faces) 707 | { 708 | unsigned int textureID; 709 | glGenTextures(1, &textureID); 710 | glBindTexture(GL_TEXTURE_CUBE_MAP, textureID); 711 | 712 | int width, height, nrChannels; 713 | 714 | for (unsigned int i = 0; i < faces.size(); i++) 715 | { 716 | 717 | unsigned char* data = stbi_load(faces[i].c_str(), &width, &height, &nrChannels, 0); 718 | 719 | if (data) 720 | { 721 | glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 722 | 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data 723 | ); 724 | stbi_image_free(data); 725 | } 726 | else 727 | { 728 | std::cout << "Cubemap texture failed to load at path: " << faces[i] << std::endl; 729 | stbi_image_free(data); 730 | } 731 | } 732 | glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 733 | glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 734 | glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 735 | glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 736 | glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); 737 | 738 | return textureID; 739 | } 740 | 741 | 742 | unsigned int loadTexture(char const* path) 743 | { 744 | unsigned int textureID; 745 | glGenTextures(1, &textureID); 746 | int width, height, nrComponents; 747 | unsigned char* data = stbi_load(path, &width, &height, &nrComponents, 0); 748 | if (data) 749 | { 750 | GLenum format; 751 | if (nrComponents == 1) 752 | format = GL_RED; 753 | else if (nrComponents == 3) 754 | format = GL_RGB; 755 | else if (nrComponents == 4) 756 | format = GL_RGBA; 757 | glBindTexture(GL_TEXTURE_2D, textureID); 758 | glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data); 759 | glGenerateMipmap(GL_TEXTURE_2D); 760 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); 761 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); 762 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); 763 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 764 | stbi_image_free(data); 765 | } 766 | else 767 | { 768 | std::cout << "Texture failed to load at path: " << path << std::endl; 769 | stbi_image_free(data); 770 | } 771 | return textureID; 772 | } 773 | 774 | 775 | void RenderText(Shader& shader, std::string text, float x, float y, float scale, glm::vec3 color) 776 | { 777 | // activate corresponding render state 778 | shader.use(); 779 | glUniform3f(glGetUniformLocation(shader.ID, "textColor"), color.x, color.y, color.z); 780 | glActiveTexture(GL_TEXTURE0); 781 | glBindVertexArray(VAO); 782 | 783 | // iterate through all characters 784 | std::string::const_iterator c; 785 | for (c = text.begin(); c != text.end(); c++) 786 | { 787 | Character ch = Characters[*c]; 788 | 789 | float xpos = x + ch.Bearing.x * scale; 790 | float ypos = y - (ch.Size.y - ch.Bearing.y) * scale; 791 | 792 | float w = ch.Size.x * scale; 793 | float h = ch.Size.y * scale; 794 | // update VBO for each character 795 | float vertices[6][4] = { 796 | { xpos, ypos + h, 0.0f, 0.0f }, 797 | { xpos, ypos, 0.0f, 1.0f }, 798 | { xpos + w, ypos, 1.0f, 1.0f }, 799 | 800 | { xpos, ypos + h, 0.0f, 0.0f }, 801 | { xpos + w, ypos, 1.0f, 1.0f }, 802 | { xpos + w, ypos + h, 1.0f, 0.0f } 803 | }; 804 | // render glyph texture over quad 805 | 806 | glBindVertexArray(VAO); 807 | glBindTexture(GL_TEXTURE_2D, ch.TextureID); 808 | glBindBuffer(GL_ARRAY_BUFFER, VBO); 809 | glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices); 810 | 811 | glBindBuffer(GL_ARRAY_BUFFER, 0); 812 | 813 | glDrawArrays(GL_TRIANGLES, 0, 6); 814 | x += (ch.Advance >> 6) * scale; 815 | } 816 | glBindVertexArray(0); 817 | glBindTexture(GL_TEXTURE_2D, 0); 818 | 819 | } 820 | 821 | void GetDesktopResolution(float& horizontal, float& vertical) 822 | { 823 | RECT desktop; 824 | const HWND hDesktop = GetDesktopWindow(); 825 | GetWindowRect(hDesktop, &desktop); 826 | horizontal = desktop.right; 827 | vertical = desktop.bottom; 828 | } -------------------------------------------------------------------------------- /assimp-vc140-mt.dll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/assimp-vc140-mt.dll -------------------------------------------------------------------------------- /assimp.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/assimp.lib -------------------------------------------------------------------------------- /build_windows.sh: -------------------------------------------------------------------------------- 1 | mkdir -p out 2 | cd out 3 | 4 | cmake -G"Visual Studio 16 2019" ${COMMON_CMAKE_CONFIG_PARAMS} ../ 5 | cmake --build . --config Debug -------------------------------------------------------------------------------- /camera.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #ifndef CAMERA_H 3 | #define CAMERA_H 4 | // Credit to learnopengl.com 5 | #include 6 | #include 7 | #include 8 | 9 | #include 10 | 11 | 12 | enum Camera_Movement { 13 | FORWARD, 14 | BACKWARD, 15 | LEFT, 16 | RIGHT 17 | }; 18 | 19 | 20 | const float YAW = -90.0f; 21 | const float PITCH = 0.0f; 22 | const float SPEED = 2.5f; 23 | const float SENSITIVITY = 0.1f; 24 | const float ZOOM = 45.0f; 25 | 26 | 27 | // An abstract camera class that processes input and calculates the corresponding Euler Angles, Vectors and Matrices for use in OpenGL 28 | class Camera 29 | { 30 | public: 31 | // camera Attributes 32 | glm::vec3 Position; 33 | glm::vec3 Front; 34 | glm::vec3 Up; 35 | glm::vec3 Right; 36 | glm::vec3 WorldUp; 37 | // euler Angles 38 | float Yaw; 39 | float Pitch; 40 | // camera options 41 | float MovementSpeed; 42 | float MouseSensitivity; 43 | float Zoom; 44 | 45 | // constructor with vectors 46 | Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) 47 | { 48 | Position = position; 49 | WorldUp = up; 50 | Yaw = yaw; 51 | Pitch = pitch; 52 | updateCameraVectors(); 53 | } 54 | // constructor with scalar values 55 | Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM) 56 | { 57 | Position = glm::vec3(posX, posY, posZ); 58 | WorldUp = glm::vec3(upX, upY, upZ); 59 | Yaw = yaw; 60 | Pitch = pitch; 61 | updateCameraVectors(); 62 | } 63 | 64 | // returns the view matrix calculated using Euler Angles and the LookAt Matrix 65 | glm::mat4 GetViewMatrix() 66 | { 67 | return glm::lookAt(Position, Position + Front, Up); 68 | } 69 | 70 | // processes input received from any keyboard-like input system. Accepts input parameter in the form of camera defined ENUM (to abstract it from windowing systems) 71 | void ProcessKeyboard(Camera_Movement direction, float deltaTime) 72 | { 73 | float velocity = MovementSpeed * deltaTime; 74 | if (direction == FORWARD) 75 | Position += Front * velocity; 76 | if (direction == BACKWARD) 77 | Position -= Front * velocity; 78 | if (direction == LEFT) 79 | Position -= Right * velocity; 80 | if (direction == RIGHT) 81 | Position += Right * velocity; 82 | } 83 | 84 | // processes input received from a mouse input system. Expects the offset value in both the x and y direction. 85 | void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true) 86 | { 87 | xoffset *= MouseSensitivity; 88 | yoffset *= MouseSensitivity; 89 | 90 | Yaw += xoffset; 91 | Pitch += yoffset; 92 | 93 | // make sure that when pitch is out of bounds, screen doesn't get flipped 94 | if (constrainPitch) 95 | { 96 | if (Pitch > 89.0f) 97 | Pitch = 89.0f; 98 | if (Pitch < -89.0f) 99 | Pitch = -89.0f; 100 | } 101 | 102 | // update Front, Right and Up Vectors using the updated Euler angles 103 | updateCameraVectors(); 104 | } 105 | 106 | // processes input received from a mouse scroll-wheel event. Only requires input on the vertical wheel-axis 107 | void ProcessMouseScroll(float yoffset) 108 | { 109 | Zoom -= (float)yoffset; 110 | if (Zoom < 1.0f) 111 | Zoom = 1.0f; 112 | if (Zoom > 45.0f) 113 | Zoom = 45.0f; 114 | } 115 | 116 | private: 117 | // calculates the front vector from the Camera's (updated) Euler Angles 118 | void updateCameraVectors() 119 | { 120 | // calculate the new Front vector 121 | glm::vec3 front; 122 | front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch)); 123 | front.y = sin(glm::radians(Pitch)); 124 | front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch)); 125 | Front = glm::normalize(front); 126 | // also re-calculate the Right and Up vector 127 | Right = glm::normalize(glm::cross(Front, WorldUp)); // normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement. 128 | Up = glm::normalize(glm::cross(Right, Front)); 129 | } 130 | }; 131 | #endif -------------------------------------------------------------------------------- /filesystem.h: -------------------------------------------------------------------------------- 1 | #ifndef FILESYSTEM_H 2 | #define FILESYSTEM_H 3 | 4 | #include 5 | #include 6 | #include "root_directory.h" // This is a configuration file generated by CMake. 7 | 8 | class FileSystem 9 | { 10 | public: 11 | #pragma warning(disable: 4996) 12 | private: 13 | typedef std::string (*Builder) (const std::string& path); 14 | 15 | public: 16 | static std::string getPath(const std::string& path) 17 | { 18 | static std::string(*pathBuilder)(std::string const &) = getPathBuilder(); 19 | return (*pathBuilder)(path); 20 | } 21 | 22 | private: 23 | static std::string const & getRoot() 24 | { 25 | 26 | static char const * envRoot = getenv("LOGL_ROOT_PATH"); 27 | static char const * givenRoot = (envRoot != nullptr ? envRoot : logl_root); 28 | static std::string root = (givenRoot != nullptr ? givenRoot : ""); 29 | return root; 30 | } 31 | 32 | //static std::string(*foo (std::string const &)) getPathBuilder() 33 | static Builder getPathBuilder() 34 | { 35 | if (getRoot() != "") 36 | return &FileSystem::getPathRelativeRoot; 37 | else 38 | return &FileSystem::getPathRelativeBinary; 39 | } 40 | 41 | static std::string getPathRelativeRoot(const std::string& path) 42 | { 43 | return getRoot() + std::string("/") + path; 44 | } 45 | 46 | static std::string getPathRelativeBinary(const std::string& path) 47 | { 48 | return "../../../" + path; 49 | } 50 | 51 | 52 | }; 53 | 54 | // FILESYSTEM_H 55 | #endif 56 | -------------------------------------------------------------------------------- /fonts/Antonio-Bold.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/fonts/Antonio-Bold.ttf -------------------------------------------------------------------------------- /fonts/Antonio-Light.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/fonts/Antonio-Light.ttf -------------------------------------------------------------------------------- /fonts/Antonio-Regular.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/fonts/Antonio-Regular.ttf -------------------------------------------------------------------------------- /fonts/OCRAEXT.TTF: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/fonts/OCRAEXT.TTF -------------------------------------------------------------------------------- /fonts/SIL Open Font License.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2011-12, vernon adams (vern@newtypography.co.uk), with Reserved Font Names 'Antonio' 2 | 3 | This Font Software is licensed under the SIL Open Font License, Version 1.1. 4 | This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL 5 | 6 | ----------------------------------------------------------- 7 | SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 8 | ----------------------------------------------------------- 9 | 10 | PREAMBLE 11 | The goals of the Open Font License (OFL) are to stimulate worldwide development of collaborative font projects, to support the font creation efforts of academic and linguistic communities, and to provide a free and open framework in which fonts may be shared and improved in partnership with others. 12 | 13 | The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The requirement for fonts to remain under this license does not apply to any document created using the fonts or their derivatives. 14 | 15 | DEFINITIONS 16 | "Font Software" refers to the set of files released by the Copyright Holder(s) under this license and clearly marked as such. This may include source files, build scripts and documentation. 17 | 18 | "Reserved Font Name" refers to any names specified as such after the copyright statement(s). 19 | 20 | "Original Version" refers to the collection of Font Software components as distributed by the Copyright Holder(s). 21 | 22 | "Modified Version" refers to any derivative made by adding to, deleting, or substituting -- in part or in whole -- any of the components of the Original Version, by changing formats or by porting the Font Software to a new environment. 23 | 24 | "Author" refers to any designer, engineer, programmer, technical writer or other person who contributed to the Font Software. 25 | 26 | PERMISSION & CONDITIONS 27 | Permission is hereby granted, free of charge, to any person obtaining a copy of the Font Software, to use, study, copy, merge, embed, modify, redistribute, and sell modified and unmodified copies of the Font Software, subject to the following conditions: 28 | 29 | 1) Neither the Font Software nor any of its individual components, in Original or Modified Versions, may be sold by itself. 30 | 31 | 2) Original or Modified Versions of the Font Software may be bundled, redistributed and/or sold with any software, provided that each copy contains the above copyright notice and this license. These can be included either as stand-alone text files, human-readable headers or in the appropriate machine-readable metadata fields within text or binary files as long as those fields can be easily viewed by the user. 32 | 33 | 3) No Modified Version of the Font Software may use the Reserved Font Name(s) unless explicit written permission is granted by the corresponding Copyright Holder. This restriction only applies to the primary font name as presented to the users. 34 | 35 | 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font Software shall not be used to promote, endorse or advertise any Modified Version, except to acknowledge the contribution(s) of the Copyright Holder(s) and the Author(s) or with their explicit written permission. 36 | 37 | 5) The Font Software, modified or unmodified, in part or in whole, must be distributed entirely under this license, and must not be distributed under any other license. The requirement for fonts to remain under this license does not apply to any document created using the Font Software. 38 | 39 | TERMINATION 40 | This license becomes null and void if any of the above conditions are not met. 41 | 42 | DISCLAIMER 43 | THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. -------------------------------------------------------------------------------- /freetype.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/freetype.lib -------------------------------------------------------------------------------- /glad.c: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | OpenGL loader generated by glad 0.1.33 on Wed Apr 22 10:46:53 2020. 4 | 5 | Language/Generator: C/C++ 6 | Specification: gl 7 | APIs: gl=3.3 8 | Profile: compatibility 9 | Extensions: 10 | 11 | Loader: True 12 | Local files: False 13 | Omit khrplatform: False 14 | Reproducible: False 15 | 16 | Commandline: 17 | --profile="compatibility" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" 18 | Online: 19 | https://glad.dav1d.de/#profile=compatibility&language=c&specification=gl&loader=on&api=gl%3D3.3 20 | */ 21 | 22 | #include 23 | #include 24 | #include 25 | #include 26 | 27 | static void* get_proc(const char *namez); 28 | 29 | #if defined(_WIN32) || defined(__CYGWIN__) 30 | #ifndef _WINDOWS_ 31 | #undef APIENTRY 32 | #endif 33 | #include 34 | static HMODULE libGL; 35 | 36 | typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); 37 | static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; 38 | 39 | #ifdef _MSC_VER 40 | #ifdef __has_include 41 | #if __has_include() 42 | #define HAVE_WINAPIFAMILY 1 43 | #endif 44 | #elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ 45 | #define HAVE_WINAPIFAMILY 1 46 | #endif 47 | #endif 48 | 49 | #ifdef HAVE_WINAPIFAMILY 50 | #include 51 | #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) 52 | #define IS_UWP 1 53 | #endif 54 | #endif 55 | 56 | static 57 | int open_gl(void) { 58 | #ifndef IS_UWP 59 | libGL = LoadLibraryW(L"opengl32.dll"); 60 | if(libGL != NULL) { 61 | void (* tmp)(void); 62 | tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); 63 | gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; 64 | return gladGetProcAddressPtr != NULL; 65 | } 66 | #endif 67 | 68 | return 0; 69 | } 70 | 71 | static 72 | void close_gl(void) { 73 | if(libGL != NULL) { 74 | FreeLibrary((HMODULE) libGL); 75 | libGL = NULL; 76 | } 77 | } 78 | #else 79 | #include 80 | static void* libGL; 81 | 82 | #if !defined(__APPLE__) && !defined(__HAIKU__) 83 | typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); 84 | static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; 85 | #endif 86 | 87 | static 88 | int open_gl(void) { 89 | #ifdef __APPLE__ 90 | static const char *NAMES[] = { 91 | "../Frameworks/OpenGL.framework/OpenGL", 92 | "/Library/Frameworks/OpenGL.framework/OpenGL", 93 | "/System/Library/Frameworks/OpenGL.framework/OpenGL", 94 | "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" 95 | }; 96 | #else 97 | static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; 98 | #endif 99 | 100 | unsigned int index = 0; 101 | for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { 102 | libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); 103 | 104 | if(libGL != NULL) { 105 | #if defined(__APPLE__) || defined(__HAIKU__) 106 | return 1; 107 | #else 108 | gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, 109 | "glXGetProcAddressARB"); 110 | return gladGetProcAddressPtr != NULL; 111 | #endif 112 | } 113 | } 114 | 115 | return 0; 116 | } 117 | 118 | static 119 | void close_gl(void) { 120 | if(libGL != NULL) { 121 | dlclose(libGL); 122 | libGL = NULL; 123 | } 124 | } 125 | #endif 126 | 127 | static 128 | void* get_proc(const char *namez) { 129 | void* result = NULL; 130 | if(libGL == NULL) return NULL; 131 | 132 | #if !defined(__APPLE__) && !defined(__HAIKU__) 133 | if(gladGetProcAddressPtr != NULL) { 134 | result = gladGetProcAddressPtr(namez); 135 | } 136 | #endif 137 | if(result == NULL) { 138 | #if defined(_WIN32) || defined(__CYGWIN__) 139 | result = (void*)GetProcAddress((HMODULE) libGL, namez); 140 | #else 141 | result = dlsym(libGL, namez); 142 | #endif 143 | } 144 | 145 | return result; 146 | } 147 | 148 | int gladLoadGL(void) { 149 | int status = 0; 150 | 151 | if(open_gl()) { 152 | status = gladLoadGLLoader(&get_proc); 153 | close_gl(); 154 | } 155 | 156 | return status; 157 | } 158 | 159 | struct gladGLversionStruct GLVersion = { 0, 0 }; 160 | 161 | #if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) 162 | #define _GLAD_IS_SOME_NEW_VERSION 1 163 | #endif 164 | 165 | static int max_loaded_major; 166 | static int max_loaded_minor; 167 | 168 | static const char *exts = NULL; 169 | static int num_exts_i = 0; 170 | static char **exts_i = NULL; 171 | 172 | static int get_exts(void) { 173 | #ifdef _GLAD_IS_SOME_NEW_VERSION 174 | if(max_loaded_major < 3) { 175 | #endif 176 | exts = (const char *)glGetString(GL_EXTENSIONS); 177 | #ifdef _GLAD_IS_SOME_NEW_VERSION 178 | } else { 179 | unsigned int index; 180 | 181 | num_exts_i = 0; 182 | glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); 183 | if (num_exts_i > 0) { 184 | exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); 185 | } 186 | 187 | if (exts_i == NULL) { 188 | return 0; 189 | } 190 | 191 | for(index = 0; index < (unsigned)num_exts_i; index++) { 192 | const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); 193 | size_t len = strlen(gl_str_tmp); 194 | 195 | char *local_str = (char*)malloc((len+1) * sizeof(char)); 196 | if(local_str != NULL) { 197 | memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); 198 | } 199 | exts_i[index] = local_str; 200 | } 201 | } 202 | #endif 203 | return 1; 204 | } 205 | 206 | static void free_exts(void) { 207 | if (exts_i != NULL) { 208 | int index; 209 | for(index = 0; index < num_exts_i; index++) { 210 | free((char *)exts_i[index]); 211 | } 212 | free((void *)exts_i); 213 | exts_i = NULL; 214 | } 215 | } 216 | 217 | static int has_ext(const char *ext) { 218 | #ifdef _GLAD_IS_SOME_NEW_VERSION 219 | if(max_loaded_major < 3) { 220 | #endif 221 | const char *extensions; 222 | const char *loc; 223 | const char *terminator; 224 | extensions = exts; 225 | if(extensions == NULL || ext == NULL) { 226 | return 0; 227 | } 228 | 229 | while(1) { 230 | loc = strstr(extensions, ext); 231 | if(loc == NULL) { 232 | return 0; 233 | } 234 | 235 | terminator = loc + strlen(ext); 236 | if((loc == extensions || *(loc - 1) == ' ') && 237 | (*terminator == ' ' || *terminator == '\0')) { 238 | return 1; 239 | } 240 | extensions = terminator; 241 | } 242 | #ifdef _GLAD_IS_SOME_NEW_VERSION 243 | } else { 244 | int index; 245 | if(exts_i == NULL) return 0; 246 | for(index = 0; index < num_exts_i; index++) { 247 | const char *e = exts_i[index]; 248 | 249 | if(exts_i[index] != NULL && strcmp(e, ext) == 0) { 250 | return 1; 251 | } 252 | } 253 | } 254 | #endif 255 | 256 | return 0; 257 | } 258 | int GLAD_GL_VERSION_1_0 = 0; 259 | int GLAD_GL_VERSION_1_1 = 0; 260 | int GLAD_GL_VERSION_1_2 = 0; 261 | int GLAD_GL_VERSION_1_3 = 0; 262 | int GLAD_GL_VERSION_1_4 = 0; 263 | int GLAD_GL_VERSION_1_5 = 0; 264 | int GLAD_GL_VERSION_2_0 = 0; 265 | int GLAD_GL_VERSION_2_1 = 0; 266 | int GLAD_GL_VERSION_3_0 = 0; 267 | int GLAD_GL_VERSION_3_1 = 0; 268 | int GLAD_GL_VERSION_3_2 = 0; 269 | int GLAD_GL_VERSION_3_3 = 0; 270 | PFNGLACCUMPROC glad_glAccum = NULL; 271 | PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; 272 | PFNGLALPHAFUNCPROC glad_glAlphaFunc = NULL; 273 | PFNGLARETEXTURESRESIDENTPROC glad_glAreTexturesResident = NULL; 274 | PFNGLARRAYELEMENTPROC glad_glArrayElement = NULL; 275 | PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; 276 | PFNGLBEGINPROC glad_glBegin = NULL; 277 | PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; 278 | PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; 279 | PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; 280 | PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; 281 | PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; 282 | PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; 283 | PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; 284 | PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; 285 | PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; 286 | PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; 287 | PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; 288 | PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; 289 | PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; 290 | PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; 291 | PFNGLBITMAPPROC glad_glBitmap = NULL; 292 | PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; 293 | PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; 294 | PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; 295 | PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; 296 | PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; 297 | PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; 298 | PFNGLBUFFERDATAPROC glad_glBufferData = NULL; 299 | PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; 300 | PFNGLCALLLISTPROC glad_glCallList = NULL; 301 | PFNGLCALLLISTSPROC glad_glCallLists = NULL; 302 | PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; 303 | PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; 304 | PFNGLCLEARPROC glad_glClear = NULL; 305 | PFNGLCLEARACCUMPROC glad_glClearAccum = NULL; 306 | PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; 307 | PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; 308 | PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; 309 | PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; 310 | PFNGLCLEARCOLORPROC glad_glClearColor = NULL; 311 | PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; 312 | PFNGLCLEARINDEXPROC glad_glClearIndex = NULL; 313 | PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; 314 | PFNGLCLIENTACTIVETEXTUREPROC glad_glClientActiveTexture = NULL; 315 | PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; 316 | PFNGLCLIPPLANEPROC glad_glClipPlane = NULL; 317 | PFNGLCOLOR3BPROC glad_glColor3b = NULL; 318 | PFNGLCOLOR3BVPROC glad_glColor3bv = NULL; 319 | PFNGLCOLOR3DPROC glad_glColor3d = NULL; 320 | PFNGLCOLOR3DVPROC glad_glColor3dv = NULL; 321 | PFNGLCOLOR3FPROC glad_glColor3f = NULL; 322 | PFNGLCOLOR3FVPROC glad_glColor3fv = NULL; 323 | PFNGLCOLOR3IPROC glad_glColor3i = NULL; 324 | PFNGLCOLOR3IVPROC glad_glColor3iv = NULL; 325 | PFNGLCOLOR3SPROC glad_glColor3s = NULL; 326 | PFNGLCOLOR3SVPROC glad_glColor3sv = NULL; 327 | PFNGLCOLOR3UBPROC glad_glColor3ub = NULL; 328 | PFNGLCOLOR3UBVPROC glad_glColor3ubv = NULL; 329 | PFNGLCOLOR3UIPROC glad_glColor3ui = NULL; 330 | PFNGLCOLOR3UIVPROC glad_glColor3uiv = NULL; 331 | PFNGLCOLOR3USPROC glad_glColor3us = NULL; 332 | PFNGLCOLOR3USVPROC glad_glColor3usv = NULL; 333 | PFNGLCOLOR4BPROC glad_glColor4b = NULL; 334 | PFNGLCOLOR4BVPROC glad_glColor4bv = NULL; 335 | PFNGLCOLOR4DPROC glad_glColor4d = NULL; 336 | PFNGLCOLOR4DVPROC glad_glColor4dv = NULL; 337 | PFNGLCOLOR4FPROC glad_glColor4f = NULL; 338 | PFNGLCOLOR4FVPROC glad_glColor4fv = NULL; 339 | PFNGLCOLOR4IPROC glad_glColor4i = NULL; 340 | PFNGLCOLOR4IVPROC glad_glColor4iv = NULL; 341 | PFNGLCOLOR4SPROC glad_glColor4s = NULL; 342 | PFNGLCOLOR4SVPROC glad_glColor4sv = NULL; 343 | PFNGLCOLOR4UBPROC glad_glColor4ub = NULL; 344 | PFNGLCOLOR4UBVPROC glad_glColor4ubv = NULL; 345 | PFNGLCOLOR4UIPROC glad_glColor4ui = NULL; 346 | PFNGLCOLOR4UIVPROC glad_glColor4uiv = NULL; 347 | PFNGLCOLOR4USPROC glad_glColor4us = NULL; 348 | PFNGLCOLOR4USVPROC glad_glColor4usv = NULL; 349 | PFNGLCOLORMASKPROC glad_glColorMask = NULL; 350 | PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; 351 | PFNGLCOLORMATERIALPROC glad_glColorMaterial = NULL; 352 | PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; 353 | PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; 354 | PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; 355 | PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; 356 | PFNGLCOLORPOINTERPROC glad_glColorPointer = NULL; 357 | PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; 358 | PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; 359 | PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; 360 | PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; 361 | PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; 362 | PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; 363 | PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; 364 | PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; 365 | PFNGLCOPYPIXELSPROC glad_glCopyPixels = NULL; 366 | PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; 367 | PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; 368 | PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; 369 | PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; 370 | PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; 371 | PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; 372 | PFNGLCREATESHADERPROC glad_glCreateShader = NULL; 373 | PFNGLCULLFACEPROC glad_glCullFace = NULL; 374 | PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; 375 | PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; 376 | PFNGLDELETELISTSPROC glad_glDeleteLists = NULL; 377 | PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; 378 | PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; 379 | PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; 380 | PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; 381 | PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; 382 | PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; 383 | PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; 384 | PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; 385 | PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; 386 | PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; 387 | PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; 388 | PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; 389 | PFNGLDISABLEPROC glad_glDisable = NULL; 390 | PFNGLDISABLECLIENTSTATEPROC glad_glDisableClientState = NULL; 391 | PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; 392 | PFNGLDISABLEIPROC glad_glDisablei = NULL; 393 | PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; 394 | PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; 395 | PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; 396 | PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; 397 | PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; 398 | PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; 399 | PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; 400 | PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; 401 | PFNGLDRAWPIXELSPROC glad_glDrawPixels = NULL; 402 | PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; 403 | PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; 404 | PFNGLEDGEFLAGPROC glad_glEdgeFlag = NULL; 405 | PFNGLEDGEFLAGPOINTERPROC glad_glEdgeFlagPointer = NULL; 406 | PFNGLEDGEFLAGVPROC glad_glEdgeFlagv = NULL; 407 | PFNGLENABLEPROC glad_glEnable = NULL; 408 | PFNGLENABLECLIENTSTATEPROC glad_glEnableClientState = NULL; 409 | PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; 410 | PFNGLENABLEIPROC glad_glEnablei = NULL; 411 | PFNGLENDPROC glad_glEnd = NULL; 412 | PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; 413 | PFNGLENDLISTPROC glad_glEndList = NULL; 414 | PFNGLENDQUERYPROC glad_glEndQuery = NULL; 415 | PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; 416 | PFNGLEVALCOORD1DPROC glad_glEvalCoord1d = NULL; 417 | PFNGLEVALCOORD1DVPROC glad_glEvalCoord1dv = NULL; 418 | PFNGLEVALCOORD1FPROC glad_glEvalCoord1f = NULL; 419 | PFNGLEVALCOORD1FVPROC glad_glEvalCoord1fv = NULL; 420 | PFNGLEVALCOORD2DPROC glad_glEvalCoord2d = NULL; 421 | PFNGLEVALCOORD2DVPROC glad_glEvalCoord2dv = NULL; 422 | PFNGLEVALCOORD2FPROC glad_glEvalCoord2f = NULL; 423 | PFNGLEVALCOORD2FVPROC glad_glEvalCoord2fv = NULL; 424 | PFNGLEVALMESH1PROC glad_glEvalMesh1 = NULL; 425 | PFNGLEVALMESH2PROC glad_glEvalMesh2 = NULL; 426 | PFNGLEVALPOINT1PROC glad_glEvalPoint1 = NULL; 427 | PFNGLEVALPOINT2PROC glad_glEvalPoint2 = NULL; 428 | PFNGLFEEDBACKBUFFERPROC glad_glFeedbackBuffer = NULL; 429 | PFNGLFENCESYNCPROC glad_glFenceSync = NULL; 430 | PFNGLFINISHPROC glad_glFinish = NULL; 431 | PFNGLFLUSHPROC glad_glFlush = NULL; 432 | PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; 433 | PFNGLFOGCOORDPOINTERPROC glad_glFogCoordPointer = NULL; 434 | PFNGLFOGCOORDDPROC glad_glFogCoordd = NULL; 435 | PFNGLFOGCOORDDVPROC glad_glFogCoorddv = NULL; 436 | PFNGLFOGCOORDFPROC glad_glFogCoordf = NULL; 437 | PFNGLFOGCOORDFVPROC glad_glFogCoordfv = NULL; 438 | PFNGLFOGFPROC glad_glFogf = NULL; 439 | PFNGLFOGFVPROC glad_glFogfv = NULL; 440 | PFNGLFOGIPROC glad_glFogi = NULL; 441 | PFNGLFOGIVPROC glad_glFogiv = NULL; 442 | PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; 443 | PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; 444 | PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; 445 | PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; 446 | PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; 447 | PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; 448 | PFNGLFRONTFACEPROC glad_glFrontFace = NULL; 449 | PFNGLFRUSTUMPROC glad_glFrustum = NULL; 450 | PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; 451 | PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; 452 | PFNGLGENLISTSPROC glad_glGenLists = NULL; 453 | PFNGLGENQUERIESPROC glad_glGenQueries = NULL; 454 | PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; 455 | PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; 456 | PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; 457 | PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; 458 | PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; 459 | PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; 460 | PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; 461 | PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; 462 | PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; 463 | PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; 464 | PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; 465 | PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; 466 | PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; 467 | PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; 468 | PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; 469 | PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; 470 | PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; 471 | PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; 472 | PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; 473 | PFNGLGETCLIPPLANEPROC glad_glGetClipPlane = NULL; 474 | PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; 475 | PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; 476 | PFNGLGETERRORPROC glad_glGetError = NULL; 477 | PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; 478 | PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; 479 | PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; 480 | PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; 481 | PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; 482 | PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; 483 | PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; 484 | PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; 485 | PFNGLGETLIGHTFVPROC glad_glGetLightfv = NULL; 486 | PFNGLGETLIGHTIVPROC glad_glGetLightiv = NULL; 487 | PFNGLGETMAPDVPROC glad_glGetMapdv = NULL; 488 | PFNGLGETMAPFVPROC glad_glGetMapfv = NULL; 489 | PFNGLGETMAPIVPROC glad_glGetMapiv = NULL; 490 | PFNGLGETMATERIALFVPROC glad_glGetMaterialfv = NULL; 491 | PFNGLGETMATERIALIVPROC glad_glGetMaterialiv = NULL; 492 | PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; 493 | PFNGLGETPIXELMAPFVPROC glad_glGetPixelMapfv = NULL; 494 | PFNGLGETPIXELMAPUIVPROC glad_glGetPixelMapuiv = NULL; 495 | PFNGLGETPIXELMAPUSVPROC glad_glGetPixelMapusv = NULL; 496 | PFNGLGETPOINTERVPROC glad_glGetPointerv = NULL; 497 | PFNGLGETPOLYGONSTIPPLEPROC glad_glGetPolygonStipple = NULL; 498 | PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; 499 | PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; 500 | PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; 501 | PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; 502 | PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; 503 | PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; 504 | PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; 505 | PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; 506 | PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; 507 | PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; 508 | PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; 509 | PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; 510 | PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; 511 | PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; 512 | PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; 513 | PFNGLGETSTRINGPROC glad_glGetString = NULL; 514 | PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; 515 | PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; 516 | PFNGLGETTEXENVFVPROC glad_glGetTexEnvfv = NULL; 517 | PFNGLGETTEXENVIVPROC glad_glGetTexEnviv = NULL; 518 | PFNGLGETTEXGENDVPROC glad_glGetTexGendv = NULL; 519 | PFNGLGETTEXGENFVPROC glad_glGetTexGenfv = NULL; 520 | PFNGLGETTEXGENIVPROC glad_glGetTexGeniv = NULL; 521 | PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; 522 | PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; 523 | PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; 524 | PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; 525 | PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; 526 | PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; 527 | PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; 528 | PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; 529 | PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; 530 | PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; 531 | PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; 532 | PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; 533 | PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; 534 | PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; 535 | PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; 536 | PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; 537 | PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; 538 | PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; 539 | PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; 540 | PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; 541 | PFNGLHINTPROC glad_glHint = NULL; 542 | PFNGLINDEXMASKPROC glad_glIndexMask = NULL; 543 | PFNGLINDEXPOINTERPROC glad_glIndexPointer = NULL; 544 | PFNGLINDEXDPROC glad_glIndexd = NULL; 545 | PFNGLINDEXDVPROC glad_glIndexdv = NULL; 546 | PFNGLINDEXFPROC glad_glIndexf = NULL; 547 | PFNGLINDEXFVPROC glad_glIndexfv = NULL; 548 | PFNGLINDEXIPROC glad_glIndexi = NULL; 549 | PFNGLINDEXIVPROC glad_glIndexiv = NULL; 550 | PFNGLINDEXSPROC glad_glIndexs = NULL; 551 | PFNGLINDEXSVPROC glad_glIndexsv = NULL; 552 | PFNGLINDEXUBPROC glad_glIndexub = NULL; 553 | PFNGLINDEXUBVPROC glad_glIndexubv = NULL; 554 | PFNGLINITNAMESPROC glad_glInitNames = NULL; 555 | PFNGLINTERLEAVEDARRAYSPROC glad_glInterleavedArrays = NULL; 556 | PFNGLISBUFFERPROC glad_glIsBuffer = NULL; 557 | PFNGLISENABLEDPROC glad_glIsEnabled = NULL; 558 | PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; 559 | PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; 560 | PFNGLISLISTPROC glad_glIsList = NULL; 561 | PFNGLISPROGRAMPROC glad_glIsProgram = NULL; 562 | PFNGLISQUERYPROC glad_glIsQuery = NULL; 563 | PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; 564 | PFNGLISSAMPLERPROC glad_glIsSampler = NULL; 565 | PFNGLISSHADERPROC glad_glIsShader = NULL; 566 | PFNGLISSYNCPROC glad_glIsSync = NULL; 567 | PFNGLISTEXTUREPROC glad_glIsTexture = NULL; 568 | PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; 569 | PFNGLLIGHTMODELFPROC glad_glLightModelf = NULL; 570 | PFNGLLIGHTMODELFVPROC glad_glLightModelfv = NULL; 571 | PFNGLLIGHTMODELIPROC glad_glLightModeli = NULL; 572 | PFNGLLIGHTMODELIVPROC glad_glLightModeliv = NULL; 573 | PFNGLLIGHTFPROC glad_glLightf = NULL; 574 | PFNGLLIGHTFVPROC glad_glLightfv = NULL; 575 | PFNGLLIGHTIPROC glad_glLighti = NULL; 576 | PFNGLLIGHTIVPROC glad_glLightiv = NULL; 577 | PFNGLLINESTIPPLEPROC glad_glLineStipple = NULL; 578 | PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; 579 | PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; 580 | PFNGLLISTBASEPROC glad_glListBase = NULL; 581 | PFNGLLOADIDENTITYPROC glad_glLoadIdentity = NULL; 582 | PFNGLLOADMATRIXDPROC glad_glLoadMatrixd = NULL; 583 | PFNGLLOADMATRIXFPROC glad_glLoadMatrixf = NULL; 584 | PFNGLLOADNAMEPROC glad_glLoadName = NULL; 585 | PFNGLLOADTRANSPOSEMATRIXDPROC glad_glLoadTransposeMatrixd = NULL; 586 | PFNGLLOADTRANSPOSEMATRIXFPROC glad_glLoadTransposeMatrixf = NULL; 587 | PFNGLLOGICOPPROC glad_glLogicOp = NULL; 588 | PFNGLMAP1DPROC glad_glMap1d = NULL; 589 | PFNGLMAP1FPROC glad_glMap1f = NULL; 590 | PFNGLMAP2DPROC glad_glMap2d = NULL; 591 | PFNGLMAP2FPROC glad_glMap2f = NULL; 592 | PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; 593 | PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; 594 | PFNGLMAPGRID1DPROC glad_glMapGrid1d = NULL; 595 | PFNGLMAPGRID1FPROC glad_glMapGrid1f = NULL; 596 | PFNGLMAPGRID2DPROC glad_glMapGrid2d = NULL; 597 | PFNGLMAPGRID2FPROC glad_glMapGrid2f = NULL; 598 | PFNGLMATERIALFPROC glad_glMaterialf = NULL; 599 | PFNGLMATERIALFVPROC glad_glMaterialfv = NULL; 600 | PFNGLMATERIALIPROC glad_glMateriali = NULL; 601 | PFNGLMATERIALIVPROC glad_glMaterialiv = NULL; 602 | PFNGLMATRIXMODEPROC glad_glMatrixMode = NULL; 603 | PFNGLMULTMATRIXDPROC glad_glMultMatrixd = NULL; 604 | PFNGLMULTMATRIXFPROC glad_glMultMatrixf = NULL; 605 | PFNGLMULTTRANSPOSEMATRIXDPROC glad_glMultTransposeMatrixd = NULL; 606 | PFNGLMULTTRANSPOSEMATRIXFPROC glad_glMultTransposeMatrixf = NULL; 607 | PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; 608 | PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; 609 | PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; 610 | PFNGLMULTITEXCOORD1DPROC glad_glMultiTexCoord1d = NULL; 611 | PFNGLMULTITEXCOORD1DVPROC glad_glMultiTexCoord1dv = NULL; 612 | PFNGLMULTITEXCOORD1FPROC glad_glMultiTexCoord1f = NULL; 613 | PFNGLMULTITEXCOORD1FVPROC glad_glMultiTexCoord1fv = NULL; 614 | PFNGLMULTITEXCOORD1IPROC glad_glMultiTexCoord1i = NULL; 615 | PFNGLMULTITEXCOORD1IVPROC glad_glMultiTexCoord1iv = NULL; 616 | PFNGLMULTITEXCOORD1SPROC glad_glMultiTexCoord1s = NULL; 617 | PFNGLMULTITEXCOORD1SVPROC glad_glMultiTexCoord1sv = NULL; 618 | PFNGLMULTITEXCOORD2DPROC glad_glMultiTexCoord2d = NULL; 619 | PFNGLMULTITEXCOORD2DVPROC glad_glMultiTexCoord2dv = NULL; 620 | PFNGLMULTITEXCOORD2FPROC glad_glMultiTexCoord2f = NULL; 621 | PFNGLMULTITEXCOORD2FVPROC glad_glMultiTexCoord2fv = NULL; 622 | PFNGLMULTITEXCOORD2IPROC glad_glMultiTexCoord2i = NULL; 623 | PFNGLMULTITEXCOORD2IVPROC glad_glMultiTexCoord2iv = NULL; 624 | PFNGLMULTITEXCOORD2SPROC glad_glMultiTexCoord2s = NULL; 625 | PFNGLMULTITEXCOORD2SVPROC glad_glMultiTexCoord2sv = NULL; 626 | PFNGLMULTITEXCOORD3DPROC glad_glMultiTexCoord3d = NULL; 627 | PFNGLMULTITEXCOORD3DVPROC glad_glMultiTexCoord3dv = NULL; 628 | PFNGLMULTITEXCOORD3FPROC glad_glMultiTexCoord3f = NULL; 629 | PFNGLMULTITEXCOORD3FVPROC glad_glMultiTexCoord3fv = NULL; 630 | PFNGLMULTITEXCOORD3IPROC glad_glMultiTexCoord3i = NULL; 631 | PFNGLMULTITEXCOORD3IVPROC glad_glMultiTexCoord3iv = NULL; 632 | PFNGLMULTITEXCOORD3SPROC glad_glMultiTexCoord3s = NULL; 633 | PFNGLMULTITEXCOORD3SVPROC glad_glMultiTexCoord3sv = NULL; 634 | PFNGLMULTITEXCOORD4DPROC glad_glMultiTexCoord4d = NULL; 635 | PFNGLMULTITEXCOORD4DVPROC glad_glMultiTexCoord4dv = NULL; 636 | PFNGLMULTITEXCOORD4FPROC glad_glMultiTexCoord4f = NULL; 637 | PFNGLMULTITEXCOORD4FVPROC glad_glMultiTexCoord4fv = NULL; 638 | PFNGLMULTITEXCOORD4IPROC glad_glMultiTexCoord4i = NULL; 639 | PFNGLMULTITEXCOORD4IVPROC glad_glMultiTexCoord4iv = NULL; 640 | PFNGLMULTITEXCOORD4SPROC glad_glMultiTexCoord4s = NULL; 641 | PFNGLMULTITEXCOORD4SVPROC glad_glMultiTexCoord4sv = NULL; 642 | PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; 643 | PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; 644 | PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; 645 | PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; 646 | PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; 647 | PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; 648 | PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; 649 | PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; 650 | PFNGLNEWLISTPROC glad_glNewList = NULL; 651 | PFNGLNORMAL3BPROC glad_glNormal3b = NULL; 652 | PFNGLNORMAL3BVPROC glad_glNormal3bv = NULL; 653 | PFNGLNORMAL3DPROC glad_glNormal3d = NULL; 654 | PFNGLNORMAL3DVPROC glad_glNormal3dv = NULL; 655 | PFNGLNORMAL3FPROC glad_glNormal3f = NULL; 656 | PFNGLNORMAL3FVPROC glad_glNormal3fv = NULL; 657 | PFNGLNORMAL3IPROC glad_glNormal3i = NULL; 658 | PFNGLNORMAL3IVPROC glad_glNormal3iv = NULL; 659 | PFNGLNORMAL3SPROC glad_glNormal3s = NULL; 660 | PFNGLNORMAL3SVPROC glad_glNormal3sv = NULL; 661 | PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; 662 | PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; 663 | PFNGLNORMALPOINTERPROC glad_glNormalPointer = NULL; 664 | PFNGLORTHOPROC glad_glOrtho = NULL; 665 | PFNGLPASSTHROUGHPROC glad_glPassThrough = NULL; 666 | PFNGLPIXELMAPFVPROC glad_glPixelMapfv = NULL; 667 | PFNGLPIXELMAPUIVPROC glad_glPixelMapuiv = NULL; 668 | PFNGLPIXELMAPUSVPROC glad_glPixelMapusv = NULL; 669 | PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; 670 | PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; 671 | PFNGLPIXELTRANSFERFPROC glad_glPixelTransferf = NULL; 672 | PFNGLPIXELTRANSFERIPROC glad_glPixelTransferi = NULL; 673 | PFNGLPIXELZOOMPROC glad_glPixelZoom = NULL; 674 | PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; 675 | PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; 676 | PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; 677 | PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; 678 | PFNGLPOINTSIZEPROC glad_glPointSize = NULL; 679 | PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; 680 | PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; 681 | PFNGLPOLYGONSTIPPLEPROC glad_glPolygonStipple = NULL; 682 | PFNGLPOPATTRIBPROC glad_glPopAttrib = NULL; 683 | PFNGLPOPCLIENTATTRIBPROC glad_glPopClientAttrib = NULL; 684 | PFNGLPOPMATRIXPROC glad_glPopMatrix = NULL; 685 | PFNGLPOPNAMEPROC glad_glPopName = NULL; 686 | PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; 687 | PFNGLPRIORITIZETEXTURESPROC glad_glPrioritizeTextures = NULL; 688 | PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; 689 | PFNGLPUSHATTRIBPROC glad_glPushAttrib = NULL; 690 | PFNGLPUSHCLIENTATTRIBPROC glad_glPushClientAttrib = NULL; 691 | PFNGLPUSHMATRIXPROC glad_glPushMatrix = NULL; 692 | PFNGLPUSHNAMEPROC glad_glPushName = NULL; 693 | PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; 694 | PFNGLRASTERPOS2DPROC glad_glRasterPos2d = NULL; 695 | PFNGLRASTERPOS2DVPROC glad_glRasterPos2dv = NULL; 696 | PFNGLRASTERPOS2FPROC glad_glRasterPos2f = NULL; 697 | PFNGLRASTERPOS2FVPROC glad_glRasterPos2fv = NULL; 698 | PFNGLRASTERPOS2IPROC glad_glRasterPos2i = NULL; 699 | PFNGLRASTERPOS2IVPROC glad_glRasterPos2iv = NULL; 700 | PFNGLRASTERPOS2SPROC glad_glRasterPos2s = NULL; 701 | PFNGLRASTERPOS2SVPROC glad_glRasterPos2sv = NULL; 702 | PFNGLRASTERPOS3DPROC glad_glRasterPos3d = NULL; 703 | PFNGLRASTERPOS3DVPROC glad_glRasterPos3dv = NULL; 704 | PFNGLRASTERPOS3FPROC glad_glRasterPos3f = NULL; 705 | PFNGLRASTERPOS3FVPROC glad_glRasterPos3fv = NULL; 706 | PFNGLRASTERPOS3IPROC glad_glRasterPos3i = NULL; 707 | PFNGLRASTERPOS3IVPROC glad_glRasterPos3iv = NULL; 708 | PFNGLRASTERPOS3SPROC glad_glRasterPos3s = NULL; 709 | PFNGLRASTERPOS3SVPROC glad_glRasterPos3sv = NULL; 710 | PFNGLRASTERPOS4DPROC glad_glRasterPos4d = NULL; 711 | PFNGLRASTERPOS4DVPROC glad_glRasterPos4dv = NULL; 712 | PFNGLRASTERPOS4FPROC glad_glRasterPos4f = NULL; 713 | PFNGLRASTERPOS4FVPROC glad_glRasterPos4fv = NULL; 714 | PFNGLRASTERPOS4IPROC glad_glRasterPos4i = NULL; 715 | PFNGLRASTERPOS4IVPROC glad_glRasterPos4iv = NULL; 716 | PFNGLRASTERPOS4SPROC glad_glRasterPos4s = NULL; 717 | PFNGLRASTERPOS4SVPROC glad_glRasterPos4sv = NULL; 718 | PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; 719 | PFNGLREADPIXELSPROC glad_glReadPixels = NULL; 720 | PFNGLRECTDPROC glad_glRectd = NULL; 721 | PFNGLRECTDVPROC glad_glRectdv = NULL; 722 | PFNGLRECTFPROC glad_glRectf = NULL; 723 | PFNGLRECTFVPROC glad_glRectfv = NULL; 724 | PFNGLRECTIPROC glad_glRecti = NULL; 725 | PFNGLRECTIVPROC glad_glRectiv = NULL; 726 | PFNGLRECTSPROC glad_glRects = NULL; 727 | PFNGLRECTSVPROC glad_glRectsv = NULL; 728 | PFNGLRENDERMODEPROC glad_glRenderMode = NULL; 729 | PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; 730 | PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; 731 | PFNGLROTATEDPROC glad_glRotated = NULL; 732 | PFNGLROTATEFPROC glad_glRotatef = NULL; 733 | PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; 734 | PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; 735 | PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; 736 | PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; 737 | PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; 738 | PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; 739 | PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; 740 | PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; 741 | PFNGLSCALEDPROC glad_glScaled = NULL; 742 | PFNGLSCALEFPROC glad_glScalef = NULL; 743 | PFNGLSCISSORPROC glad_glScissor = NULL; 744 | PFNGLSECONDARYCOLOR3BPROC glad_glSecondaryColor3b = NULL; 745 | PFNGLSECONDARYCOLOR3BVPROC glad_glSecondaryColor3bv = NULL; 746 | PFNGLSECONDARYCOLOR3DPROC glad_glSecondaryColor3d = NULL; 747 | PFNGLSECONDARYCOLOR3DVPROC glad_glSecondaryColor3dv = NULL; 748 | PFNGLSECONDARYCOLOR3FPROC glad_glSecondaryColor3f = NULL; 749 | PFNGLSECONDARYCOLOR3FVPROC glad_glSecondaryColor3fv = NULL; 750 | PFNGLSECONDARYCOLOR3IPROC glad_glSecondaryColor3i = NULL; 751 | PFNGLSECONDARYCOLOR3IVPROC glad_glSecondaryColor3iv = NULL; 752 | PFNGLSECONDARYCOLOR3SPROC glad_glSecondaryColor3s = NULL; 753 | PFNGLSECONDARYCOLOR3SVPROC glad_glSecondaryColor3sv = NULL; 754 | PFNGLSECONDARYCOLOR3UBPROC glad_glSecondaryColor3ub = NULL; 755 | PFNGLSECONDARYCOLOR3UBVPROC glad_glSecondaryColor3ubv = NULL; 756 | PFNGLSECONDARYCOLOR3UIPROC glad_glSecondaryColor3ui = NULL; 757 | PFNGLSECONDARYCOLOR3UIVPROC glad_glSecondaryColor3uiv = NULL; 758 | PFNGLSECONDARYCOLOR3USPROC glad_glSecondaryColor3us = NULL; 759 | PFNGLSECONDARYCOLOR3USVPROC glad_glSecondaryColor3usv = NULL; 760 | PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; 761 | PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; 762 | PFNGLSECONDARYCOLORPOINTERPROC glad_glSecondaryColorPointer = NULL; 763 | PFNGLSELECTBUFFERPROC glad_glSelectBuffer = NULL; 764 | PFNGLSHADEMODELPROC glad_glShadeModel = NULL; 765 | PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; 766 | PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; 767 | PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; 768 | PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; 769 | PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; 770 | PFNGLSTENCILOPPROC glad_glStencilOp = NULL; 771 | PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; 772 | PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; 773 | PFNGLTEXCOORD1DPROC glad_glTexCoord1d = NULL; 774 | PFNGLTEXCOORD1DVPROC glad_glTexCoord1dv = NULL; 775 | PFNGLTEXCOORD1FPROC glad_glTexCoord1f = NULL; 776 | PFNGLTEXCOORD1FVPROC glad_glTexCoord1fv = NULL; 777 | PFNGLTEXCOORD1IPROC glad_glTexCoord1i = NULL; 778 | PFNGLTEXCOORD1IVPROC glad_glTexCoord1iv = NULL; 779 | PFNGLTEXCOORD1SPROC glad_glTexCoord1s = NULL; 780 | PFNGLTEXCOORD1SVPROC glad_glTexCoord1sv = NULL; 781 | PFNGLTEXCOORD2DPROC glad_glTexCoord2d = NULL; 782 | PFNGLTEXCOORD2DVPROC glad_glTexCoord2dv = NULL; 783 | PFNGLTEXCOORD2FPROC glad_glTexCoord2f = NULL; 784 | PFNGLTEXCOORD2FVPROC glad_glTexCoord2fv = NULL; 785 | PFNGLTEXCOORD2IPROC glad_glTexCoord2i = NULL; 786 | PFNGLTEXCOORD2IVPROC glad_glTexCoord2iv = NULL; 787 | PFNGLTEXCOORD2SPROC glad_glTexCoord2s = NULL; 788 | PFNGLTEXCOORD2SVPROC glad_glTexCoord2sv = NULL; 789 | PFNGLTEXCOORD3DPROC glad_glTexCoord3d = NULL; 790 | PFNGLTEXCOORD3DVPROC glad_glTexCoord3dv = NULL; 791 | PFNGLTEXCOORD3FPROC glad_glTexCoord3f = NULL; 792 | PFNGLTEXCOORD3FVPROC glad_glTexCoord3fv = NULL; 793 | PFNGLTEXCOORD3IPROC glad_glTexCoord3i = NULL; 794 | PFNGLTEXCOORD3IVPROC glad_glTexCoord3iv = NULL; 795 | PFNGLTEXCOORD3SPROC glad_glTexCoord3s = NULL; 796 | PFNGLTEXCOORD3SVPROC glad_glTexCoord3sv = NULL; 797 | PFNGLTEXCOORD4DPROC glad_glTexCoord4d = NULL; 798 | PFNGLTEXCOORD4DVPROC glad_glTexCoord4dv = NULL; 799 | PFNGLTEXCOORD4FPROC glad_glTexCoord4f = NULL; 800 | PFNGLTEXCOORD4FVPROC glad_glTexCoord4fv = NULL; 801 | PFNGLTEXCOORD4IPROC glad_glTexCoord4i = NULL; 802 | PFNGLTEXCOORD4IVPROC glad_glTexCoord4iv = NULL; 803 | PFNGLTEXCOORD4SPROC glad_glTexCoord4s = NULL; 804 | PFNGLTEXCOORD4SVPROC glad_glTexCoord4sv = NULL; 805 | PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; 806 | PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; 807 | PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; 808 | PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; 809 | PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; 810 | PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; 811 | PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; 812 | PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; 813 | PFNGLTEXCOORDPOINTERPROC glad_glTexCoordPointer = NULL; 814 | PFNGLTEXENVFPROC glad_glTexEnvf = NULL; 815 | PFNGLTEXENVFVPROC glad_glTexEnvfv = NULL; 816 | PFNGLTEXENVIPROC glad_glTexEnvi = NULL; 817 | PFNGLTEXENVIVPROC glad_glTexEnviv = NULL; 818 | PFNGLTEXGENDPROC glad_glTexGend = NULL; 819 | PFNGLTEXGENDVPROC glad_glTexGendv = NULL; 820 | PFNGLTEXGENFPROC glad_glTexGenf = NULL; 821 | PFNGLTEXGENFVPROC glad_glTexGenfv = NULL; 822 | PFNGLTEXGENIPROC glad_glTexGeni = NULL; 823 | PFNGLTEXGENIVPROC glad_glTexGeniv = NULL; 824 | PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; 825 | PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; 826 | PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; 827 | PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; 828 | PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; 829 | PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; 830 | PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; 831 | PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; 832 | PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; 833 | PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; 834 | PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; 835 | PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; 836 | PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; 837 | PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; 838 | PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; 839 | PFNGLTRANSLATEDPROC glad_glTranslated = NULL; 840 | PFNGLTRANSLATEFPROC glad_glTranslatef = NULL; 841 | PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; 842 | PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; 843 | PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; 844 | PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; 845 | PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; 846 | PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; 847 | PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; 848 | PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; 849 | PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; 850 | PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; 851 | PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; 852 | PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; 853 | PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; 854 | PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; 855 | PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; 856 | PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; 857 | PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; 858 | PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; 859 | PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; 860 | PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; 861 | PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; 862 | PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; 863 | PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; 864 | PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; 865 | PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; 866 | PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; 867 | PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; 868 | PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; 869 | PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; 870 | PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; 871 | PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; 872 | PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; 873 | PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; 874 | PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; 875 | PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; 876 | PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; 877 | PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; 878 | PFNGLVERTEX2DPROC glad_glVertex2d = NULL; 879 | PFNGLVERTEX2DVPROC glad_glVertex2dv = NULL; 880 | PFNGLVERTEX2FPROC glad_glVertex2f = NULL; 881 | PFNGLVERTEX2FVPROC glad_glVertex2fv = NULL; 882 | PFNGLVERTEX2IPROC glad_glVertex2i = NULL; 883 | PFNGLVERTEX2IVPROC glad_glVertex2iv = NULL; 884 | PFNGLVERTEX2SPROC glad_glVertex2s = NULL; 885 | PFNGLVERTEX2SVPROC glad_glVertex2sv = NULL; 886 | PFNGLVERTEX3DPROC glad_glVertex3d = NULL; 887 | PFNGLVERTEX3DVPROC glad_glVertex3dv = NULL; 888 | PFNGLVERTEX3FPROC glad_glVertex3f = NULL; 889 | PFNGLVERTEX3FVPROC glad_glVertex3fv = NULL; 890 | PFNGLVERTEX3IPROC glad_glVertex3i = NULL; 891 | PFNGLVERTEX3IVPROC glad_glVertex3iv = NULL; 892 | PFNGLVERTEX3SPROC glad_glVertex3s = NULL; 893 | PFNGLVERTEX3SVPROC glad_glVertex3sv = NULL; 894 | PFNGLVERTEX4DPROC glad_glVertex4d = NULL; 895 | PFNGLVERTEX4DVPROC glad_glVertex4dv = NULL; 896 | PFNGLVERTEX4FPROC glad_glVertex4f = NULL; 897 | PFNGLVERTEX4FVPROC glad_glVertex4fv = NULL; 898 | PFNGLVERTEX4IPROC glad_glVertex4i = NULL; 899 | PFNGLVERTEX4IVPROC glad_glVertex4iv = NULL; 900 | PFNGLVERTEX4SPROC glad_glVertex4s = NULL; 901 | PFNGLVERTEX4SVPROC glad_glVertex4sv = NULL; 902 | PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; 903 | PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; 904 | PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; 905 | PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; 906 | PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; 907 | PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; 908 | PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; 909 | PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; 910 | PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; 911 | PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; 912 | PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; 913 | PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; 914 | PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; 915 | PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; 916 | PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; 917 | PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; 918 | PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; 919 | PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; 920 | PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; 921 | PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; 922 | PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; 923 | PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; 924 | PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; 925 | PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; 926 | PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; 927 | PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; 928 | PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; 929 | PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; 930 | PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; 931 | PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; 932 | PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; 933 | PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; 934 | PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; 935 | PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; 936 | PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; 937 | PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; 938 | PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; 939 | PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; 940 | PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; 941 | PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; 942 | PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; 943 | PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; 944 | PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; 945 | PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; 946 | PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; 947 | PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; 948 | PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; 949 | PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; 950 | PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; 951 | PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; 952 | PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; 953 | PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; 954 | PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; 955 | PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; 956 | PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; 957 | PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; 958 | PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; 959 | PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; 960 | PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; 961 | PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; 962 | PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; 963 | PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; 964 | PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; 965 | PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; 966 | PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; 967 | PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; 968 | PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; 969 | PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; 970 | PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; 971 | PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; 972 | PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; 973 | PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; 974 | PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; 975 | PFNGLVERTEXPOINTERPROC glad_glVertexPointer = NULL; 976 | PFNGLVIEWPORTPROC glad_glViewport = NULL; 977 | PFNGLWAITSYNCPROC glad_glWaitSync = NULL; 978 | PFNGLWINDOWPOS2DPROC glad_glWindowPos2d = NULL; 979 | PFNGLWINDOWPOS2DVPROC glad_glWindowPos2dv = NULL; 980 | PFNGLWINDOWPOS2FPROC glad_glWindowPos2f = NULL; 981 | PFNGLWINDOWPOS2FVPROC glad_glWindowPos2fv = NULL; 982 | PFNGLWINDOWPOS2IPROC glad_glWindowPos2i = NULL; 983 | PFNGLWINDOWPOS2IVPROC glad_glWindowPos2iv = NULL; 984 | PFNGLWINDOWPOS2SPROC glad_glWindowPos2s = NULL; 985 | PFNGLWINDOWPOS2SVPROC glad_glWindowPos2sv = NULL; 986 | PFNGLWINDOWPOS3DPROC glad_glWindowPos3d = NULL; 987 | PFNGLWINDOWPOS3DVPROC glad_glWindowPos3dv = NULL; 988 | PFNGLWINDOWPOS3FPROC glad_glWindowPos3f = NULL; 989 | PFNGLWINDOWPOS3FVPROC glad_glWindowPos3fv = NULL; 990 | PFNGLWINDOWPOS3IPROC glad_glWindowPos3i = NULL; 991 | PFNGLWINDOWPOS3IVPROC glad_glWindowPos3iv = NULL; 992 | PFNGLWINDOWPOS3SPROC glad_glWindowPos3s = NULL; 993 | PFNGLWINDOWPOS3SVPROC glad_glWindowPos3sv = NULL; 994 | static void load_GL_VERSION_1_0(GLADloadproc load) { 995 | if(!GLAD_GL_VERSION_1_0) return; 996 | glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); 997 | glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); 998 | glad_glHint = (PFNGLHINTPROC)load("glHint"); 999 | glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); 1000 | glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); 1001 | glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); 1002 | glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); 1003 | glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); 1004 | glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); 1005 | glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); 1006 | glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); 1007 | glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); 1008 | glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); 1009 | glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); 1010 | glad_glClear = (PFNGLCLEARPROC)load("glClear"); 1011 | glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); 1012 | glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); 1013 | glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); 1014 | glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); 1015 | glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); 1016 | glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); 1017 | glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); 1018 | glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); 1019 | glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); 1020 | glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); 1021 | glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); 1022 | glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); 1023 | glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); 1024 | glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); 1025 | glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); 1026 | glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); 1027 | glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); 1028 | glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); 1029 | glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); 1030 | glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); 1031 | glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); 1032 | glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); 1033 | glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); 1034 | glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); 1035 | glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); 1036 | glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); 1037 | glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); 1038 | glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); 1039 | glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); 1040 | glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); 1041 | glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); 1042 | glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); 1043 | glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); 1044 | glad_glNewList = (PFNGLNEWLISTPROC)load("glNewList"); 1045 | glad_glEndList = (PFNGLENDLISTPROC)load("glEndList"); 1046 | glad_glCallList = (PFNGLCALLLISTPROC)load("glCallList"); 1047 | glad_glCallLists = (PFNGLCALLLISTSPROC)load("glCallLists"); 1048 | glad_glDeleteLists = (PFNGLDELETELISTSPROC)load("glDeleteLists"); 1049 | glad_glGenLists = (PFNGLGENLISTSPROC)load("glGenLists"); 1050 | glad_glListBase = (PFNGLLISTBASEPROC)load("glListBase"); 1051 | glad_glBegin = (PFNGLBEGINPROC)load("glBegin"); 1052 | glad_glBitmap = (PFNGLBITMAPPROC)load("glBitmap"); 1053 | glad_glColor3b = (PFNGLCOLOR3BPROC)load("glColor3b"); 1054 | glad_glColor3bv = (PFNGLCOLOR3BVPROC)load("glColor3bv"); 1055 | glad_glColor3d = (PFNGLCOLOR3DPROC)load("glColor3d"); 1056 | glad_glColor3dv = (PFNGLCOLOR3DVPROC)load("glColor3dv"); 1057 | glad_glColor3f = (PFNGLCOLOR3FPROC)load("glColor3f"); 1058 | glad_glColor3fv = (PFNGLCOLOR3FVPROC)load("glColor3fv"); 1059 | glad_glColor3i = (PFNGLCOLOR3IPROC)load("glColor3i"); 1060 | glad_glColor3iv = (PFNGLCOLOR3IVPROC)load("glColor3iv"); 1061 | glad_glColor3s = (PFNGLCOLOR3SPROC)load("glColor3s"); 1062 | glad_glColor3sv = (PFNGLCOLOR3SVPROC)load("glColor3sv"); 1063 | glad_glColor3ub = (PFNGLCOLOR3UBPROC)load("glColor3ub"); 1064 | glad_glColor3ubv = (PFNGLCOLOR3UBVPROC)load("glColor3ubv"); 1065 | glad_glColor3ui = (PFNGLCOLOR3UIPROC)load("glColor3ui"); 1066 | glad_glColor3uiv = (PFNGLCOLOR3UIVPROC)load("glColor3uiv"); 1067 | glad_glColor3us = (PFNGLCOLOR3USPROC)load("glColor3us"); 1068 | glad_glColor3usv = (PFNGLCOLOR3USVPROC)load("glColor3usv"); 1069 | glad_glColor4b = (PFNGLCOLOR4BPROC)load("glColor4b"); 1070 | glad_glColor4bv = (PFNGLCOLOR4BVPROC)load("glColor4bv"); 1071 | glad_glColor4d = (PFNGLCOLOR4DPROC)load("glColor4d"); 1072 | glad_glColor4dv = (PFNGLCOLOR4DVPROC)load("glColor4dv"); 1073 | glad_glColor4f = (PFNGLCOLOR4FPROC)load("glColor4f"); 1074 | glad_glColor4fv = (PFNGLCOLOR4FVPROC)load("glColor4fv"); 1075 | glad_glColor4i = (PFNGLCOLOR4IPROC)load("glColor4i"); 1076 | glad_glColor4iv = (PFNGLCOLOR4IVPROC)load("glColor4iv"); 1077 | glad_glColor4s = (PFNGLCOLOR4SPROC)load("glColor4s"); 1078 | glad_glColor4sv = (PFNGLCOLOR4SVPROC)load("glColor4sv"); 1079 | glad_glColor4ub = (PFNGLCOLOR4UBPROC)load("glColor4ub"); 1080 | glad_glColor4ubv = (PFNGLCOLOR4UBVPROC)load("glColor4ubv"); 1081 | glad_glColor4ui = (PFNGLCOLOR4UIPROC)load("glColor4ui"); 1082 | glad_glColor4uiv = (PFNGLCOLOR4UIVPROC)load("glColor4uiv"); 1083 | glad_glColor4us = (PFNGLCOLOR4USPROC)load("glColor4us"); 1084 | glad_glColor4usv = (PFNGLCOLOR4USVPROC)load("glColor4usv"); 1085 | glad_glEdgeFlag = (PFNGLEDGEFLAGPROC)load("glEdgeFlag"); 1086 | glad_glEdgeFlagv = (PFNGLEDGEFLAGVPROC)load("glEdgeFlagv"); 1087 | glad_glEnd = (PFNGLENDPROC)load("glEnd"); 1088 | glad_glIndexd = (PFNGLINDEXDPROC)load("glIndexd"); 1089 | glad_glIndexdv = (PFNGLINDEXDVPROC)load("glIndexdv"); 1090 | glad_glIndexf = (PFNGLINDEXFPROC)load("glIndexf"); 1091 | glad_glIndexfv = (PFNGLINDEXFVPROC)load("glIndexfv"); 1092 | glad_glIndexi = (PFNGLINDEXIPROC)load("glIndexi"); 1093 | glad_glIndexiv = (PFNGLINDEXIVPROC)load("glIndexiv"); 1094 | glad_glIndexs = (PFNGLINDEXSPROC)load("glIndexs"); 1095 | glad_glIndexsv = (PFNGLINDEXSVPROC)load("glIndexsv"); 1096 | glad_glNormal3b = (PFNGLNORMAL3BPROC)load("glNormal3b"); 1097 | glad_glNormal3bv = (PFNGLNORMAL3BVPROC)load("glNormal3bv"); 1098 | glad_glNormal3d = (PFNGLNORMAL3DPROC)load("glNormal3d"); 1099 | glad_glNormal3dv = (PFNGLNORMAL3DVPROC)load("glNormal3dv"); 1100 | glad_glNormal3f = (PFNGLNORMAL3FPROC)load("glNormal3f"); 1101 | glad_glNormal3fv = (PFNGLNORMAL3FVPROC)load("glNormal3fv"); 1102 | glad_glNormal3i = (PFNGLNORMAL3IPROC)load("glNormal3i"); 1103 | glad_glNormal3iv = (PFNGLNORMAL3IVPROC)load("glNormal3iv"); 1104 | glad_glNormal3s = (PFNGLNORMAL3SPROC)load("glNormal3s"); 1105 | glad_glNormal3sv = (PFNGLNORMAL3SVPROC)load("glNormal3sv"); 1106 | glad_glRasterPos2d = (PFNGLRASTERPOS2DPROC)load("glRasterPos2d"); 1107 | glad_glRasterPos2dv = (PFNGLRASTERPOS2DVPROC)load("glRasterPos2dv"); 1108 | glad_glRasterPos2f = (PFNGLRASTERPOS2FPROC)load("glRasterPos2f"); 1109 | glad_glRasterPos2fv = (PFNGLRASTERPOS2FVPROC)load("glRasterPos2fv"); 1110 | glad_glRasterPos2i = (PFNGLRASTERPOS2IPROC)load("glRasterPos2i"); 1111 | glad_glRasterPos2iv = (PFNGLRASTERPOS2IVPROC)load("glRasterPos2iv"); 1112 | glad_glRasterPos2s = (PFNGLRASTERPOS2SPROC)load("glRasterPos2s"); 1113 | glad_glRasterPos2sv = (PFNGLRASTERPOS2SVPROC)load("glRasterPos2sv"); 1114 | glad_glRasterPos3d = (PFNGLRASTERPOS3DPROC)load("glRasterPos3d"); 1115 | glad_glRasterPos3dv = (PFNGLRASTERPOS3DVPROC)load("glRasterPos3dv"); 1116 | glad_glRasterPos3f = (PFNGLRASTERPOS3FPROC)load("glRasterPos3f"); 1117 | glad_glRasterPos3fv = (PFNGLRASTERPOS3FVPROC)load("glRasterPos3fv"); 1118 | glad_glRasterPos3i = (PFNGLRASTERPOS3IPROC)load("glRasterPos3i"); 1119 | glad_glRasterPos3iv = (PFNGLRASTERPOS3IVPROC)load("glRasterPos3iv"); 1120 | glad_glRasterPos3s = (PFNGLRASTERPOS3SPROC)load("glRasterPos3s"); 1121 | glad_glRasterPos3sv = (PFNGLRASTERPOS3SVPROC)load("glRasterPos3sv"); 1122 | glad_glRasterPos4d = (PFNGLRASTERPOS4DPROC)load("glRasterPos4d"); 1123 | glad_glRasterPos4dv = (PFNGLRASTERPOS4DVPROC)load("glRasterPos4dv"); 1124 | glad_glRasterPos4f = (PFNGLRASTERPOS4FPROC)load("glRasterPos4f"); 1125 | glad_glRasterPos4fv = (PFNGLRASTERPOS4FVPROC)load("glRasterPos4fv"); 1126 | glad_glRasterPos4i = (PFNGLRASTERPOS4IPROC)load("glRasterPos4i"); 1127 | glad_glRasterPos4iv = (PFNGLRASTERPOS4IVPROC)load("glRasterPos4iv"); 1128 | glad_glRasterPos4s = (PFNGLRASTERPOS4SPROC)load("glRasterPos4s"); 1129 | glad_glRasterPos4sv = (PFNGLRASTERPOS4SVPROC)load("glRasterPos4sv"); 1130 | glad_glRectd = (PFNGLRECTDPROC)load("glRectd"); 1131 | glad_glRectdv = (PFNGLRECTDVPROC)load("glRectdv"); 1132 | glad_glRectf = (PFNGLRECTFPROC)load("glRectf"); 1133 | glad_glRectfv = (PFNGLRECTFVPROC)load("glRectfv"); 1134 | glad_glRecti = (PFNGLRECTIPROC)load("glRecti"); 1135 | glad_glRectiv = (PFNGLRECTIVPROC)load("glRectiv"); 1136 | glad_glRects = (PFNGLRECTSPROC)load("glRects"); 1137 | glad_glRectsv = (PFNGLRECTSVPROC)load("glRectsv"); 1138 | glad_glTexCoord1d = (PFNGLTEXCOORD1DPROC)load("glTexCoord1d"); 1139 | glad_glTexCoord1dv = (PFNGLTEXCOORD1DVPROC)load("glTexCoord1dv"); 1140 | glad_glTexCoord1f = (PFNGLTEXCOORD1FPROC)load("glTexCoord1f"); 1141 | glad_glTexCoord1fv = (PFNGLTEXCOORD1FVPROC)load("glTexCoord1fv"); 1142 | glad_glTexCoord1i = (PFNGLTEXCOORD1IPROC)load("glTexCoord1i"); 1143 | glad_glTexCoord1iv = (PFNGLTEXCOORD1IVPROC)load("glTexCoord1iv"); 1144 | glad_glTexCoord1s = (PFNGLTEXCOORD1SPROC)load("glTexCoord1s"); 1145 | glad_glTexCoord1sv = (PFNGLTEXCOORD1SVPROC)load("glTexCoord1sv"); 1146 | glad_glTexCoord2d = (PFNGLTEXCOORD2DPROC)load("glTexCoord2d"); 1147 | glad_glTexCoord2dv = (PFNGLTEXCOORD2DVPROC)load("glTexCoord2dv"); 1148 | glad_glTexCoord2f = (PFNGLTEXCOORD2FPROC)load("glTexCoord2f"); 1149 | glad_glTexCoord2fv = (PFNGLTEXCOORD2FVPROC)load("glTexCoord2fv"); 1150 | glad_glTexCoord2i = (PFNGLTEXCOORD2IPROC)load("glTexCoord2i"); 1151 | glad_glTexCoord2iv = (PFNGLTEXCOORD2IVPROC)load("glTexCoord2iv"); 1152 | glad_glTexCoord2s = (PFNGLTEXCOORD2SPROC)load("glTexCoord2s"); 1153 | glad_glTexCoord2sv = (PFNGLTEXCOORD2SVPROC)load("glTexCoord2sv"); 1154 | glad_glTexCoord3d = (PFNGLTEXCOORD3DPROC)load("glTexCoord3d"); 1155 | glad_glTexCoord3dv = (PFNGLTEXCOORD3DVPROC)load("glTexCoord3dv"); 1156 | glad_glTexCoord3f = (PFNGLTEXCOORD3FPROC)load("glTexCoord3f"); 1157 | glad_glTexCoord3fv = (PFNGLTEXCOORD3FVPROC)load("glTexCoord3fv"); 1158 | glad_glTexCoord3i = (PFNGLTEXCOORD3IPROC)load("glTexCoord3i"); 1159 | glad_glTexCoord3iv = (PFNGLTEXCOORD3IVPROC)load("glTexCoord3iv"); 1160 | glad_glTexCoord3s = (PFNGLTEXCOORD3SPROC)load("glTexCoord3s"); 1161 | glad_glTexCoord3sv = (PFNGLTEXCOORD3SVPROC)load("glTexCoord3sv"); 1162 | glad_glTexCoord4d = (PFNGLTEXCOORD4DPROC)load("glTexCoord4d"); 1163 | glad_glTexCoord4dv = (PFNGLTEXCOORD4DVPROC)load("glTexCoord4dv"); 1164 | glad_glTexCoord4f = (PFNGLTEXCOORD4FPROC)load("glTexCoord4f"); 1165 | glad_glTexCoord4fv = (PFNGLTEXCOORD4FVPROC)load("glTexCoord4fv"); 1166 | glad_glTexCoord4i = (PFNGLTEXCOORD4IPROC)load("glTexCoord4i"); 1167 | glad_glTexCoord4iv = (PFNGLTEXCOORD4IVPROC)load("glTexCoord4iv"); 1168 | glad_glTexCoord4s = (PFNGLTEXCOORD4SPROC)load("glTexCoord4s"); 1169 | glad_glTexCoord4sv = (PFNGLTEXCOORD4SVPROC)load("glTexCoord4sv"); 1170 | glad_glVertex2d = (PFNGLVERTEX2DPROC)load("glVertex2d"); 1171 | glad_glVertex2dv = (PFNGLVERTEX2DVPROC)load("glVertex2dv"); 1172 | glad_glVertex2f = (PFNGLVERTEX2FPROC)load("glVertex2f"); 1173 | glad_glVertex2fv = (PFNGLVERTEX2FVPROC)load("glVertex2fv"); 1174 | glad_glVertex2i = (PFNGLVERTEX2IPROC)load("glVertex2i"); 1175 | glad_glVertex2iv = (PFNGLVERTEX2IVPROC)load("glVertex2iv"); 1176 | glad_glVertex2s = (PFNGLVERTEX2SPROC)load("glVertex2s"); 1177 | glad_glVertex2sv = (PFNGLVERTEX2SVPROC)load("glVertex2sv"); 1178 | glad_glVertex3d = (PFNGLVERTEX3DPROC)load("glVertex3d"); 1179 | glad_glVertex3dv = (PFNGLVERTEX3DVPROC)load("glVertex3dv"); 1180 | glad_glVertex3f = (PFNGLVERTEX3FPROC)load("glVertex3f"); 1181 | glad_glVertex3fv = (PFNGLVERTEX3FVPROC)load("glVertex3fv"); 1182 | glad_glVertex3i = (PFNGLVERTEX3IPROC)load("glVertex3i"); 1183 | glad_glVertex3iv = (PFNGLVERTEX3IVPROC)load("glVertex3iv"); 1184 | glad_glVertex3s = (PFNGLVERTEX3SPROC)load("glVertex3s"); 1185 | glad_glVertex3sv = (PFNGLVERTEX3SVPROC)load("glVertex3sv"); 1186 | glad_glVertex4d = (PFNGLVERTEX4DPROC)load("glVertex4d"); 1187 | glad_glVertex4dv = (PFNGLVERTEX4DVPROC)load("glVertex4dv"); 1188 | glad_glVertex4f = (PFNGLVERTEX4FPROC)load("glVertex4f"); 1189 | glad_glVertex4fv = (PFNGLVERTEX4FVPROC)load("glVertex4fv"); 1190 | glad_glVertex4i = (PFNGLVERTEX4IPROC)load("glVertex4i"); 1191 | glad_glVertex4iv = (PFNGLVERTEX4IVPROC)load("glVertex4iv"); 1192 | glad_glVertex4s = (PFNGLVERTEX4SPROC)load("glVertex4s"); 1193 | glad_glVertex4sv = (PFNGLVERTEX4SVPROC)load("glVertex4sv"); 1194 | glad_glClipPlane = (PFNGLCLIPPLANEPROC)load("glClipPlane"); 1195 | glad_glColorMaterial = (PFNGLCOLORMATERIALPROC)load("glColorMaterial"); 1196 | glad_glFogf = (PFNGLFOGFPROC)load("glFogf"); 1197 | glad_glFogfv = (PFNGLFOGFVPROC)load("glFogfv"); 1198 | glad_glFogi = (PFNGLFOGIPROC)load("glFogi"); 1199 | glad_glFogiv = (PFNGLFOGIVPROC)load("glFogiv"); 1200 | glad_glLightf = (PFNGLLIGHTFPROC)load("glLightf"); 1201 | glad_glLightfv = (PFNGLLIGHTFVPROC)load("glLightfv"); 1202 | glad_glLighti = (PFNGLLIGHTIPROC)load("glLighti"); 1203 | glad_glLightiv = (PFNGLLIGHTIVPROC)load("glLightiv"); 1204 | glad_glLightModelf = (PFNGLLIGHTMODELFPROC)load("glLightModelf"); 1205 | glad_glLightModelfv = (PFNGLLIGHTMODELFVPROC)load("glLightModelfv"); 1206 | glad_glLightModeli = (PFNGLLIGHTMODELIPROC)load("glLightModeli"); 1207 | glad_glLightModeliv = (PFNGLLIGHTMODELIVPROC)load("glLightModeliv"); 1208 | glad_glLineStipple = (PFNGLLINESTIPPLEPROC)load("glLineStipple"); 1209 | glad_glMaterialf = (PFNGLMATERIALFPROC)load("glMaterialf"); 1210 | glad_glMaterialfv = (PFNGLMATERIALFVPROC)load("glMaterialfv"); 1211 | glad_glMateriali = (PFNGLMATERIALIPROC)load("glMateriali"); 1212 | glad_glMaterialiv = (PFNGLMATERIALIVPROC)load("glMaterialiv"); 1213 | glad_glPolygonStipple = (PFNGLPOLYGONSTIPPLEPROC)load("glPolygonStipple"); 1214 | glad_glShadeModel = (PFNGLSHADEMODELPROC)load("glShadeModel"); 1215 | glad_glTexEnvf = (PFNGLTEXENVFPROC)load("glTexEnvf"); 1216 | glad_glTexEnvfv = (PFNGLTEXENVFVPROC)load("glTexEnvfv"); 1217 | glad_glTexEnvi = (PFNGLTEXENVIPROC)load("glTexEnvi"); 1218 | glad_glTexEnviv = (PFNGLTEXENVIVPROC)load("glTexEnviv"); 1219 | glad_glTexGend = (PFNGLTEXGENDPROC)load("glTexGend"); 1220 | glad_glTexGendv = (PFNGLTEXGENDVPROC)load("glTexGendv"); 1221 | glad_glTexGenf = (PFNGLTEXGENFPROC)load("glTexGenf"); 1222 | glad_glTexGenfv = (PFNGLTEXGENFVPROC)load("glTexGenfv"); 1223 | glad_glTexGeni = (PFNGLTEXGENIPROC)load("glTexGeni"); 1224 | glad_glTexGeniv = (PFNGLTEXGENIVPROC)load("glTexGeniv"); 1225 | glad_glFeedbackBuffer = (PFNGLFEEDBACKBUFFERPROC)load("glFeedbackBuffer"); 1226 | glad_glSelectBuffer = (PFNGLSELECTBUFFERPROC)load("glSelectBuffer"); 1227 | glad_glRenderMode = (PFNGLRENDERMODEPROC)load("glRenderMode"); 1228 | glad_glInitNames = (PFNGLINITNAMESPROC)load("glInitNames"); 1229 | glad_glLoadName = (PFNGLLOADNAMEPROC)load("glLoadName"); 1230 | glad_glPassThrough = (PFNGLPASSTHROUGHPROC)load("glPassThrough"); 1231 | glad_glPopName = (PFNGLPOPNAMEPROC)load("glPopName"); 1232 | glad_glPushName = (PFNGLPUSHNAMEPROC)load("glPushName"); 1233 | glad_glClearAccum = (PFNGLCLEARACCUMPROC)load("glClearAccum"); 1234 | glad_glClearIndex = (PFNGLCLEARINDEXPROC)load("glClearIndex"); 1235 | glad_glIndexMask = (PFNGLINDEXMASKPROC)load("glIndexMask"); 1236 | glad_glAccum = (PFNGLACCUMPROC)load("glAccum"); 1237 | glad_glPopAttrib = (PFNGLPOPATTRIBPROC)load("glPopAttrib"); 1238 | glad_glPushAttrib = (PFNGLPUSHATTRIBPROC)load("glPushAttrib"); 1239 | glad_glMap1d = (PFNGLMAP1DPROC)load("glMap1d"); 1240 | glad_glMap1f = (PFNGLMAP1FPROC)load("glMap1f"); 1241 | glad_glMap2d = (PFNGLMAP2DPROC)load("glMap2d"); 1242 | glad_glMap2f = (PFNGLMAP2FPROC)load("glMap2f"); 1243 | glad_glMapGrid1d = (PFNGLMAPGRID1DPROC)load("glMapGrid1d"); 1244 | glad_glMapGrid1f = (PFNGLMAPGRID1FPROC)load("glMapGrid1f"); 1245 | glad_glMapGrid2d = (PFNGLMAPGRID2DPROC)load("glMapGrid2d"); 1246 | glad_glMapGrid2f = (PFNGLMAPGRID2FPROC)load("glMapGrid2f"); 1247 | glad_glEvalCoord1d = (PFNGLEVALCOORD1DPROC)load("glEvalCoord1d"); 1248 | glad_glEvalCoord1dv = (PFNGLEVALCOORD1DVPROC)load("glEvalCoord1dv"); 1249 | glad_glEvalCoord1f = (PFNGLEVALCOORD1FPROC)load("glEvalCoord1f"); 1250 | glad_glEvalCoord1fv = (PFNGLEVALCOORD1FVPROC)load("glEvalCoord1fv"); 1251 | glad_glEvalCoord2d = (PFNGLEVALCOORD2DPROC)load("glEvalCoord2d"); 1252 | glad_glEvalCoord2dv = (PFNGLEVALCOORD2DVPROC)load("glEvalCoord2dv"); 1253 | glad_glEvalCoord2f = (PFNGLEVALCOORD2FPROC)load("glEvalCoord2f"); 1254 | glad_glEvalCoord2fv = (PFNGLEVALCOORD2FVPROC)load("glEvalCoord2fv"); 1255 | glad_glEvalMesh1 = (PFNGLEVALMESH1PROC)load("glEvalMesh1"); 1256 | glad_glEvalPoint1 = (PFNGLEVALPOINT1PROC)load("glEvalPoint1"); 1257 | glad_glEvalMesh2 = (PFNGLEVALMESH2PROC)load("glEvalMesh2"); 1258 | glad_glEvalPoint2 = (PFNGLEVALPOINT2PROC)load("glEvalPoint2"); 1259 | glad_glAlphaFunc = (PFNGLALPHAFUNCPROC)load("glAlphaFunc"); 1260 | glad_glPixelZoom = (PFNGLPIXELZOOMPROC)load("glPixelZoom"); 1261 | glad_glPixelTransferf = (PFNGLPIXELTRANSFERFPROC)load("glPixelTransferf"); 1262 | glad_glPixelTransferi = (PFNGLPIXELTRANSFERIPROC)load("glPixelTransferi"); 1263 | glad_glPixelMapfv = (PFNGLPIXELMAPFVPROC)load("glPixelMapfv"); 1264 | glad_glPixelMapuiv = (PFNGLPIXELMAPUIVPROC)load("glPixelMapuiv"); 1265 | glad_glPixelMapusv = (PFNGLPIXELMAPUSVPROC)load("glPixelMapusv"); 1266 | glad_glCopyPixels = (PFNGLCOPYPIXELSPROC)load("glCopyPixels"); 1267 | glad_glDrawPixels = (PFNGLDRAWPIXELSPROC)load("glDrawPixels"); 1268 | glad_glGetClipPlane = (PFNGLGETCLIPPLANEPROC)load("glGetClipPlane"); 1269 | glad_glGetLightfv = (PFNGLGETLIGHTFVPROC)load("glGetLightfv"); 1270 | glad_glGetLightiv = (PFNGLGETLIGHTIVPROC)load("glGetLightiv"); 1271 | glad_glGetMapdv = (PFNGLGETMAPDVPROC)load("glGetMapdv"); 1272 | glad_glGetMapfv = (PFNGLGETMAPFVPROC)load("glGetMapfv"); 1273 | glad_glGetMapiv = (PFNGLGETMAPIVPROC)load("glGetMapiv"); 1274 | glad_glGetMaterialfv = (PFNGLGETMATERIALFVPROC)load("glGetMaterialfv"); 1275 | glad_glGetMaterialiv = (PFNGLGETMATERIALIVPROC)load("glGetMaterialiv"); 1276 | glad_glGetPixelMapfv = (PFNGLGETPIXELMAPFVPROC)load("glGetPixelMapfv"); 1277 | glad_glGetPixelMapuiv = (PFNGLGETPIXELMAPUIVPROC)load("glGetPixelMapuiv"); 1278 | glad_glGetPixelMapusv = (PFNGLGETPIXELMAPUSVPROC)load("glGetPixelMapusv"); 1279 | glad_glGetPolygonStipple = (PFNGLGETPOLYGONSTIPPLEPROC)load("glGetPolygonStipple"); 1280 | glad_glGetTexEnvfv = (PFNGLGETTEXENVFVPROC)load("glGetTexEnvfv"); 1281 | glad_glGetTexEnviv = (PFNGLGETTEXENVIVPROC)load("glGetTexEnviv"); 1282 | glad_glGetTexGendv = (PFNGLGETTEXGENDVPROC)load("glGetTexGendv"); 1283 | glad_glGetTexGenfv = (PFNGLGETTEXGENFVPROC)load("glGetTexGenfv"); 1284 | glad_glGetTexGeniv = (PFNGLGETTEXGENIVPROC)load("glGetTexGeniv"); 1285 | glad_glIsList = (PFNGLISLISTPROC)load("glIsList"); 1286 | glad_glFrustum = (PFNGLFRUSTUMPROC)load("glFrustum"); 1287 | glad_glLoadIdentity = (PFNGLLOADIDENTITYPROC)load("glLoadIdentity"); 1288 | glad_glLoadMatrixf = (PFNGLLOADMATRIXFPROC)load("glLoadMatrixf"); 1289 | glad_glLoadMatrixd = (PFNGLLOADMATRIXDPROC)load("glLoadMatrixd"); 1290 | glad_glMatrixMode = (PFNGLMATRIXMODEPROC)load("glMatrixMode"); 1291 | glad_glMultMatrixf = (PFNGLMULTMATRIXFPROC)load("glMultMatrixf"); 1292 | glad_glMultMatrixd = (PFNGLMULTMATRIXDPROC)load("glMultMatrixd"); 1293 | glad_glOrtho = (PFNGLORTHOPROC)load("glOrtho"); 1294 | glad_glPopMatrix = (PFNGLPOPMATRIXPROC)load("glPopMatrix"); 1295 | glad_glPushMatrix = (PFNGLPUSHMATRIXPROC)load("glPushMatrix"); 1296 | glad_glRotated = (PFNGLROTATEDPROC)load("glRotated"); 1297 | glad_glRotatef = (PFNGLROTATEFPROC)load("glRotatef"); 1298 | glad_glScaled = (PFNGLSCALEDPROC)load("glScaled"); 1299 | glad_glScalef = (PFNGLSCALEFPROC)load("glScalef"); 1300 | glad_glTranslated = (PFNGLTRANSLATEDPROC)load("glTranslated"); 1301 | glad_glTranslatef = (PFNGLTRANSLATEFPROC)load("glTranslatef"); 1302 | } 1303 | static void load_GL_VERSION_1_1(GLADloadproc load) { 1304 | if(!GLAD_GL_VERSION_1_1) return; 1305 | glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); 1306 | glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); 1307 | glad_glGetPointerv = (PFNGLGETPOINTERVPROC)load("glGetPointerv"); 1308 | glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); 1309 | glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); 1310 | glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); 1311 | glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); 1312 | glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); 1313 | glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); 1314 | glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); 1315 | glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); 1316 | glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); 1317 | glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); 1318 | glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); 1319 | glad_glArrayElement = (PFNGLARRAYELEMENTPROC)load("glArrayElement"); 1320 | glad_glColorPointer = (PFNGLCOLORPOINTERPROC)load("glColorPointer"); 1321 | glad_glDisableClientState = (PFNGLDISABLECLIENTSTATEPROC)load("glDisableClientState"); 1322 | glad_glEdgeFlagPointer = (PFNGLEDGEFLAGPOINTERPROC)load("glEdgeFlagPointer"); 1323 | glad_glEnableClientState = (PFNGLENABLECLIENTSTATEPROC)load("glEnableClientState"); 1324 | glad_glIndexPointer = (PFNGLINDEXPOINTERPROC)load("glIndexPointer"); 1325 | glad_glInterleavedArrays = (PFNGLINTERLEAVEDARRAYSPROC)load("glInterleavedArrays"); 1326 | glad_glNormalPointer = (PFNGLNORMALPOINTERPROC)load("glNormalPointer"); 1327 | glad_glTexCoordPointer = (PFNGLTEXCOORDPOINTERPROC)load("glTexCoordPointer"); 1328 | glad_glVertexPointer = (PFNGLVERTEXPOINTERPROC)load("glVertexPointer"); 1329 | glad_glAreTexturesResident = (PFNGLARETEXTURESRESIDENTPROC)load("glAreTexturesResident"); 1330 | glad_glPrioritizeTextures = (PFNGLPRIORITIZETEXTURESPROC)load("glPrioritizeTextures"); 1331 | glad_glIndexub = (PFNGLINDEXUBPROC)load("glIndexub"); 1332 | glad_glIndexubv = (PFNGLINDEXUBVPROC)load("glIndexubv"); 1333 | glad_glPopClientAttrib = (PFNGLPOPCLIENTATTRIBPROC)load("glPopClientAttrib"); 1334 | glad_glPushClientAttrib = (PFNGLPUSHCLIENTATTRIBPROC)load("glPushClientAttrib"); 1335 | } 1336 | static void load_GL_VERSION_1_2(GLADloadproc load) { 1337 | if(!GLAD_GL_VERSION_1_2) return; 1338 | glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); 1339 | glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); 1340 | glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); 1341 | glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); 1342 | } 1343 | static void load_GL_VERSION_1_3(GLADloadproc load) { 1344 | if(!GLAD_GL_VERSION_1_3) return; 1345 | glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); 1346 | glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); 1347 | glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); 1348 | glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); 1349 | glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); 1350 | glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); 1351 | glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); 1352 | glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); 1353 | glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); 1354 | glad_glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)load("glClientActiveTexture"); 1355 | glad_glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)load("glMultiTexCoord1d"); 1356 | glad_glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)load("glMultiTexCoord1dv"); 1357 | glad_glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)load("glMultiTexCoord1f"); 1358 | glad_glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)load("glMultiTexCoord1fv"); 1359 | glad_glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)load("glMultiTexCoord1i"); 1360 | glad_glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)load("glMultiTexCoord1iv"); 1361 | glad_glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)load("glMultiTexCoord1s"); 1362 | glad_glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)load("glMultiTexCoord1sv"); 1363 | glad_glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)load("glMultiTexCoord2d"); 1364 | glad_glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)load("glMultiTexCoord2dv"); 1365 | glad_glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)load("glMultiTexCoord2f"); 1366 | glad_glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)load("glMultiTexCoord2fv"); 1367 | glad_glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)load("glMultiTexCoord2i"); 1368 | glad_glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)load("glMultiTexCoord2iv"); 1369 | glad_glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)load("glMultiTexCoord2s"); 1370 | glad_glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)load("glMultiTexCoord2sv"); 1371 | glad_glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)load("glMultiTexCoord3d"); 1372 | glad_glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)load("glMultiTexCoord3dv"); 1373 | glad_glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)load("glMultiTexCoord3f"); 1374 | glad_glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)load("glMultiTexCoord3fv"); 1375 | glad_glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)load("glMultiTexCoord3i"); 1376 | glad_glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)load("glMultiTexCoord3iv"); 1377 | glad_glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)load("glMultiTexCoord3s"); 1378 | glad_glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)load("glMultiTexCoord3sv"); 1379 | glad_glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)load("glMultiTexCoord4d"); 1380 | glad_glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)load("glMultiTexCoord4dv"); 1381 | glad_glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)load("glMultiTexCoord4f"); 1382 | glad_glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)load("glMultiTexCoord4fv"); 1383 | glad_glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)load("glMultiTexCoord4i"); 1384 | glad_glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)load("glMultiTexCoord4iv"); 1385 | glad_glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)load("glMultiTexCoord4s"); 1386 | glad_glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)load("glMultiTexCoord4sv"); 1387 | glad_glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)load("glLoadTransposeMatrixf"); 1388 | glad_glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)load("glLoadTransposeMatrixd"); 1389 | glad_glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)load("glMultTransposeMatrixf"); 1390 | glad_glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)load("glMultTransposeMatrixd"); 1391 | } 1392 | static void load_GL_VERSION_1_4(GLADloadproc load) { 1393 | if(!GLAD_GL_VERSION_1_4) return; 1394 | glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); 1395 | glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); 1396 | glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); 1397 | glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); 1398 | glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); 1399 | glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); 1400 | glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); 1401 | glad_glFogCoordf = (PFNGLFOGCOORDFPROC)load("glFogCoordf"); 1402 | glad_glFogCoordfv = (PFNGLFOGCOORDFVPROC)load("glFogCoordfv"); 1403 | glad_glFogCoordd = (PFNGLFOGCOORDDPROC)load("glFogCoordd"); 1404 | glad_glFogCoorddv = (PFNGLFOGCOORDDVPROC)load("glFogCoorddv"); 1405 | glad_glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)load("glFogCoordPointer"); 1406 | glad_glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)load("glSecondaryColor3b"); 1407 | glad_glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)load("glSecondaryColor3bv"); 1408 | glad_glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)load("glSecondaryColor3d"); 1409 | glad_glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)load("glSecondaryColor3dv"); 1410 | glad_glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)load("glSecondaryColor3f"); 1411 | glad_glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)load("glSecondaryColor3fv"); 1412 | glad_glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)load("glSecondaryColor3i"); 1413 | glad_glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)load("glSecondaryColor3iv"); 1414 | glad_glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)load("glSecondaryColor3s"); 1415 | glad_glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)load("glSecondaryColor3sv"); 1416 | glad_glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)load("glSecondaryColor3ub"); 1417 | glad_glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)load("glSecondaryColor3ubv"); 1418 | glad_glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)load("glSecondaryColor3ui"); 1419 | glad_glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)load("glSecondaryColor3uiv"); 1420 | glad_glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)load("glSecondaryColor3us"); 1421 | glad_glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)load("glSecondaryColor3usv"); 1422 | glad_glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)load("glSecondaryColorPointer"); 1423 | glad_glWindowPos2d = (PFNGLWINDOWPOS2DPROC)load("glWindowPos2d"); 1424 | glad_glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)load("glWindowPos2dv"); 1425 | glad_glWindowPos2f = (PFNGLWINDOWPOS2FPROC)load("glWindowPos2f"); 1426 | glad_glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)load("glWindowPos2fv"); 1427 | glad_glWindowPos2i = (PFNGLWINDOWPOS2IPROC)load("glWindowPos2i"); 1428 | glad_glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)load("glWindowPos2iv"); 1429 | glad_glWindowPos2s = (PFNGLWINDOWPOS2SPROC)load("glWindowPos2s"); 1430 | glad_glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)load("glWindowPos2sv"); 1431 | glad_glWindowPos3d = (PFNGLWINDOWPOS3DPROC)load("glWindowPos3d"); 1432 | glad_glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)load("glWindowPos3dv"); 1433 | glad_glWindowPos3f = (PFNGLWINDOWPOS3FPROC)load("glWindowPos3f"); 1434 | glad_glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)load("glWindowPos3fv"); 1435 | glad_glWindowPos3i = (PFNGLWINDOWPOS3IPROC)load("glWindowPos3i"); 1436 | glad_glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)load("glWindowPos3iv"); 1437 | glad_glWindowPos3s = (PFNGLWINDOWPOS3SPROC)load("glWindowPos3s"); 1438 | glad_glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)load("glWindowPos3sv"); 1439 | glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); 1440 | glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); 1441 | } 1442 | static void load_GL_VERSION_1_5(GLADloadproc load) { 1443 | if(!GLAD_GL_VERSION_1_5) return; 1444 | glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); 1445 | glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); 1446 | glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); 1447 | glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); 1448 | glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); 1449 | glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); 1450 | glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); 1451 | glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); 1452 | glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); 1453 | glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); 1454 | glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); 1455 | glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); 1456 | glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); 1457 | glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); 1458 | glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); 1459 | glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); 1460 | glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); 1461 | glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); 1462 | glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); 1463 | } 1464 | static void load_GL_VERSION_2_0(GLADloadproc load) { 1465 | if(!GLAD_GL_VERSION_2_0) return; 1466 | glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); 1467 | glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); 1468 | glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); 1469 | glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); 1470 | glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); 1471 | glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); 1472 | glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); 1473 | glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); 1474 | glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); 1475 | glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); 1476 | glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); 1477 | glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); 1478 | glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); 1479 | glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); 1480 | glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); 1481 | glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); 1482 | glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); 1483 | glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); 1484 | glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); 1485 | glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); 1486 | glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); 1487 | glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); 1488 | glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); 1489 | glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); 1490 | glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); 1491 | glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); 1492 | glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); 1493 | glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); 1494 | glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); 1495 | glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); 1496 | glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); 1497 | glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); 1498 | glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); 1499 | glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); 1500 | glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); 1501 | glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); 1502 | glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); 1503 | glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); 1504 | glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); 1505 | glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); 1506 | glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); 1507 | glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); 1508 | glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); 1509 | glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); 1510 | glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); 1511 | glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); 1512 | glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); 1513 | glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); 1514 | glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); 1515 | glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); 1516 | glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); 1517 | glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); 1518 | glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); 1519 | glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); 1520 | glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); 1521 | glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); 1522 | glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); 1523 | glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); 1524 | glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); 1525 | glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); 1526 | glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); 1527 | glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); 1528 | glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); 1529 | glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); 1530 | glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); 1531 | glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); 1532 | glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); 1533 | glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); 1534 | glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); 1535 | glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); 1536 | glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); 1537 | glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); 1538 | glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); 1539 | glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); 1540 | glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); 1541 | glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); 1542 | glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); 1543 | glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); 1544 | glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); 1545 | glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); 1546 | glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); 1547 | glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); 1548 | glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); 1549 | glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); 1550 | glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); 1551 | glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); 1552 | glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); 1553 | glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); 1554 | glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); 1555 | glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); 1556 | glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); 1557 | glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); 1558 | glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); 1559 | } 1560 | static void load_GL_VERSION_2_1(GLADloadproc load) { 1561 | if(!GLAD_GL_VERSION_2_1) return; 1562 | glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); 1563 | glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); 1564 | glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); 1565 | glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); 1566 | glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); 1567 | glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); 1568 | } 1569 | static void load_GL_VERSION_3_0(GLADloadproc load) { 1570 | if(!GLAD_GL_VERSION_3_0) return; 1571 | glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); 1572 | glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); 1573 | glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); 1574 | glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); 1575 | glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); 1576 | glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); 1577 | glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); 1578 | glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); 1579 | glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); 1580 | glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); 1581 | glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); 1582 | glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); 1583 | glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); 1584 | glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); 1585 | glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); 1586 | glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); 1587 | glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); 1588 | glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); 1589 | glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); 1590 | glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); 1591 | glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); 1592 | glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); 1593 | glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); 1594 | glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); 1595 | glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); 1596 | glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); 1597 | glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); 1598 | glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); 1599 | glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); 1600 | glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); 1601 | glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); 1602 | glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); 1603 | glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); 1604 | glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); 1605 | glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); 1606 | glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); 1607 | glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); 1608 | glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); 1609 | glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); 1610 | glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); 1611 | glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); 1612 | glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); 1613 | glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); 1614 | glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); 1615 | glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); 1616 | glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); 1617 | glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); 1618 | glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); 1619 | glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); 1620 | glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); 1621 | glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); 1622 | glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); 1623 | glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); 1624 | glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); 1625 | glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); 1626 | glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); 1627 | glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); 1628 | glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); 1629 | glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); 1630 | glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); 1631 | glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); 1632 | glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); 1633 | glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); 1634 | glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); 1635 | glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); 1636 | glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); 1637 | glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); 1638 | glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); 1639 | glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); 1640 | glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); 1641 | glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); 1642 | glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); 1643 | glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); 1644 | glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); 1645 | glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); 1646 | glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); 1647 | glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); 1648 | glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); 1649 | glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); 1650 | glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); 1651 | glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); 1652 | glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); 1653 | glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); 1654 | glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); 1655 | } 1656 | static void load_GL_VERSION_3_1(GLADloadproc load) { 1657 | if(!GLAD_GL_VERSION_3_1) return; 1658 | glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); 1659 | glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); 1660 | glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); 1661 | glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); 1662 | glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); 1663 | glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); 1664 | glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); 1665 | glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); 1666 | glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); 1667 | glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); 1668 | glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); 1669 | glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); 1670 | glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); 1671 | glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); 1672 | glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); 1673 | } 1674 | static void load_GL_VERSION_3_2(GLADloadproc load) { 1675 | if(!GLAD_GL_VERSION_3_2) return; 1676 | glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); 1677 | glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); 1678 | glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); 1679 | glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); 1680 | glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); 1681 | glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); 1682 | glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); 1683 | glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); 1684 | glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); 1685 | glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); 1686 | glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); 1687 | glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); 1688 | glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); 1689 | glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); 1690 | glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); 1691 | glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); 1692 | glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); 1693 | glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); 1694 | glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); 1695 | } 1696 | static void load_GL_VERSION_3_3(GLADloadproc load) { 1697 | if(!GLAD_GL_VERSION_3_3) return; 1698 | glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); 1699 | glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); 1700 | glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); 1701 | glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); 1702 | glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); 1703 | glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); 1704 | glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); 1705 | glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); 1706 | glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); 1707 | glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); 1708 | glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); 1709 | glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); 1710 | glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); 1711 | glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); 1712 | glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); 1713 | glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); 1714 | glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); 1715 | glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); 1716 | glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); 1717 | glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); 1718 | glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); 1719 | glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); 1720 | glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); 1721 | glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); 1722 | glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); 1723 | glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); 1724 | glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); 1725 | glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); 1726 | glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); 1727 | glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); 1728 | glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); 1729 | glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); 1730 | glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); 1731 | glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); 1732 | glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); 1733 | glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); 1734 | glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); 1735 | glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); 1736 | glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); 1737 | glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); 1738 | glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); 1739 | glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); 1740 | glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); 1741 | glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); 1742 | glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); 1743 | glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); 1744 | glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); 1745 | glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); 1746 | glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); 1747 | glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); 1748 | glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); 1749 | glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); 1750 | glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); 1751 | glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); 1752 | glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); 1753 | glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); 1754 | glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); 1755 | glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); 1756 | } 1757 | static int find_extensionsGL(void) { 1758 | if (!get_exts()) return 0; 1759 | (void)&has_ext; 1760 | free_exts(); 1761 | return 1; 1762 | } 1763 | 1764 | static void find_coreGL(void) { 1765 | 1766 | /* Thank you @elmindreda 1767 | * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 1768 | * https://github.com/glfw/glfw/blob/master/src/context.c#L36 1769 | */ 1770 | int i, major, minor; 1771 | 1772 | const char* version; 1773 | const char* prefixes[] = { 1774 | "OpenGL ES-CM ", 1775 | "OpenGL ES-CL ", 1776 | "OpenGL ES ", 1777 | NULL 1778 | }; 1779 | 1780 | version = (const char*) glGetString(GL_VERSION); 1781 | if (!version) return; 1782 | 1783 | for (i = 0; prefixes[i]; i++) { 1784 | const size_t length = strlen(prefixes[i]); 1785 | if (strncmp(version, prefixes[i], length) == 0) { 1786 | version += length; 1787 | break; 1788 | } 1789 | } 1790 | 1791 | /* PR #18 */ 1792 | #ifdef _MSC_VER 1793 | sscanf_s(version, "%d.%d", &major, &minor); 1794 | #else 1795 | sscanf(version, "%d.%d", &major, &minor); 1796 | #endif 1797 | 1798 | GLVersion.major = major; GLVersion.minor = minor; 1799 | max_loaded_major = major; max_loaded_minor = minor; 1800 | GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; 1801 | GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; 1802 | GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; 1803 | GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; 1804 | GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; 1805 | GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; 1806 | GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; 1807 | GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; 1808 | GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; 1809 | GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; 1810 | GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; 1811 | GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; 1812 | if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { 1813 | max_loaded_major = 3; 1814 | max_loaded_minor = 3; 1815 | } 1816 | } 1817 | 1818 | int gladLoadGLLoader(GLADloadproc load) { 1819 | GLVersion.major = 0; GLVersion.minor = 0; 1820 | glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); 1821 | if(glGetString == NULL) return 0; 1822 | if(glGetString(GL_VERSION) == NULL) return 0; 1823 | find_coreGL(); 1824 | load_GL_VERSION_1_0(load); 1825 | load_GL_VERSION_1_1(load); 1826 | load_GL_VERSION_1_2(load); 1827 | load_GL_VERSION_1_3(load); 1828 | load_GL_VERSION_1_4(load); 1829 | load_GL_VERSION_1_5(load); 1830 | load_GL_VERSION_2_0(load); 1831 | load_GL_VERSION_2_1(load); 1832 | load_GL_VERSION_3_0(load); 1833 | load_GL_VERSION_3_1(load); 1834 | load_GL_VERSION_3_2(load); 1835 | load_GL_VERSION_3_3(load); 1836 | 1837 | if (!find_extensionsGL()) return 0; 1838 | return GLVersion.major != 0 || GLVersion.minor != 0; 1839 | } 1840 | 1841 | -------------------------------------------------------------------------------- /glew32s.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/glew32s.lib -------------------------------------------------------------------------------- /glfw3.lib: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/glfw3.lib -------------------------------------------------------------------------------- /root_directory.h: -------------------------------------------------------------------------------- 1 | const char * logl_root = "D:/school/CS 330 computational graphics/LearnOpenGL"; 2 | -------------------------------------------------------------------------------- /shader.h: -------------------------------------------------------------------------------- 1 | #ifndef SHADER_H 2 | #define SHADER_H 3 | 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | class Shader 13 | { 14 | public: 15 | unsigned int ID; 16 | // constructor generates the shader on the fly 17 | // ------------------------------------------------------------------------ 18 | Shader(const char* vertexPath, const char* fragmentPath) 19 | { 20 | // 1. retrieve the vertex/fragment source code from filePath 21 | std::string vertexCode; 22 | std::string fragmentCode; 23 | std::ifstream vShaderFile; 24 | std::ifstream fShaderFile; 25 | // ensure ifstream objects can throw exceptions: 26 | vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit); 27 | fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit); 28 | try 29 | { 30 | // open files 31 | vShaderFile.open(vertexPath); 32 | fShaderFile.open(fragmentPath); 33 | std::stringstream vShaderStream, fShaderStream; 34 | // read file's buffer contents into streams 35 | vShaderStream << vShaderFile.rdbuf(); 36 | fShaderStream << fShaderFile.rdbuf(); 37 | // close file handlers 38 | vShaderFile.close(); 39 | fShaderFile.close(); 40 | // convert stream into string 41 | vertexCode = vShaderStream.str(); 42 | fragmentCode = fShaderStream.str(); 43 | } 44 | catch (std::ifstream::failure& e) 45 | { 46 | std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ: " << e.what() << std::endl; 47 | } 48 | const char* vShaderCode = vertexCode.c_str(); 49 | const char* fShaderCode = fragmentCode.c_str(); 50 | // 2. compile shaders 51 | unsigned int vertex, fragment; 52 | // vertex shader 53 | vertex = glCreateShader(GL_VERTEX_SHADER); 54 | glShaderSource(vertex, 1, &vShaderCode, NULL); 55 | glCompileShader(vertex); 56 | checkCompileErrors(vertex, "VERTEX"); 57 | // fragment Shader 58 | fragment = glCreateShader(GL_FRAGMENT_SHADER); 59 | glShaderSource(fragment, 1, &fShaderCode, NULL); 60 | glCompileShader(fragment); 61 | checkCompileErrors(fragment, "FRAGMENT"); 62 | // shader Program 63 | ID = glCreateProgram(); 64 | glAttachShader(ID, vertex); 65 | glAttachShader(ID, fragment); 66 | glLinkProgram(ID); 67 | checkCompileErrors(ID, "PROGRAM"); 68 | // delete the shaders as they're linked into our program now and no longer necessery 69 | glDeleteShader(vertex); 70 | glDeleteShader(fragment); 71 | 72 | } 73 | // activate the shader 74 | // ------------------------------------------------------------------------ 75 | void use() const 76 | { 77 | glUseProgram(ID); 78 | } 79 | // utility uniform functions 80 | // ------------------------------------------------------------------------ 81 | void setBool(const std::string& name, bool value) const 82 | { 83 | glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value); 84 | } 85 | // ------------------------------------------------------------------------ 86 | void setInt(const std::string& name, int value) const 87 | { 88 | glUniform1i(glGetUniformLocation(ID, name.c_str()), value); 89 | } 90 | // ------------------------------------------------------------------------ 91 | void setFloat(const std::string& name, float value) const 92 | { 93 | glUniform1f(glGetUniformLocation(ID, name.c_str()), value); 94 | } 95 | // ------------------------------------------------------------------------ 96 | void setVec2(const std::string& name, const glm::vec2& value) const 97 | { 98 | glUniform2fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]); 99 | } 100 | void setVec2(const std::string& name, float x, float y) const 101 | { 102 | glUniform2f(glGetUniformLocation(ID, name.c_str()), x, y); 103 | } 104 | // ------------------------------------------------------------------------ 105 | void setVec3(const std::string& name, const glm::vec3& value) const 106 | { 107 | glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]); 108 | } 109 | void setVec3(const std::string& name, float x, float y, float z) const 110 | { 111 | glUniform3f(glGetUniformLocation(ID, name.c_str()), x, y, z); 112 | } 113 | // ------------------------------------------------------------------------ 114 | void setVec4(const std::string& name, const glm::vec4& value) const 115 | { 116 | glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, &value[0]); 117 | } 118 | void setVec4(const std::string& name, float x, float y, float z, float w) const 119 | { 120 | glUniform4f(glGetUniformLocation(ID, name.c_str()), x, y, z, w); 121 | } 122 | // ------------------------------------------------------------------------ 123 | void setMat2(const std::string& name, const glm::mat2& mat) const 124 | { 125 | glUniformMatrix2fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]); 126 | } 127 | // ------------------------------------------------------------------------ 128 | void setMat3(const std::string& name, const glm::mat3& mat) const 129 | { 130 | glUniformMatrix3fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]); 131 | } 132 | // ------------------------------------------------------------------------ 133 | void setMat4(const std::string& name, const glm::mat4& mat) const 134 | { 135 | glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, &mat[0][0]); 136 | } 137 | 138 | private: 139 | // utility function for checking shader compilation/linking errors. 140 | // ------------------------------------------------------------------------ 141 | void checkCompileErrors(GLuint shader, std::string type) 142 | { 143 | GLint success; 144 | GLchar infoLog[1024]; 145 | if (type != "PROGRAM") 146 | { 147 | glGetShaderiv(shader, GL_COMPILE_STATUS, &success); 148 | if (!success) 149 | { 150 | glGetShaderInfoLog(shader, 1024, NULL, infoLog); 151 | std::cout << "ERROR::SHADER_COMPILATION_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl; 152 | } 153 | } 154 | else 155 | { 156 | glGetProgramiv(shader, GL_LINK_STATUS, &success); 157 | if (!success) 158 | { 159 | glGetProgramInfoLog(shader, 1024, NULL, infoLog); 160 | std::cout << "ERROR::PROGRAM_LINKING_ERROR of type: " << type << "\n" << infoLog << "\n -- --------------------------------------------------- -- " << std::endl; 161 | } 162 | } 163 | } 164 | }; 165 | #endif 166 | -------------------------------------------------------------------------------- /specular.fs: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | out vec4 FragColor; 3 | 4 | struct Material { 5 | sampler2D diffuse; 6 | sampler2D specular; 7 | float shininess; 8 | }; 9 | 10 | struct DirLight { 11 | vec3 direction; 12 | 13 | vec3 ambient; 14 | vec3 diffuse; 15 | vec3 specular; 16 | }; 17 | 18 | struct PointLight { 19 | vec3 position; 20 | 21 | float constant; 22 | float linear; 23 | float quadratic; 24 | 25 | vec3 ambient; 26 | vec3 diffuse; 27 | vec3 specular; 28 | }; 29 | 30 | struct SpotLight { 31 | vec3 position; 32 | vec3 direction; 33 | float cutOff; 34 | float outerCutOff; 35 | 36 | float constant; 37 | float linear; 38 | float quadratic; 39 | 40 | vec3 ambient; 41 | vec3 diffuse; 42 | vec3 specular; 43 | }; 44 | 45 | #define NR_POINT_LIGHTS 4 46 | 47 | in vec3 FragPos; 48 | in vec3 Normal; 49 | in vec2 TexCoords; 50 | 51 | uniform vec3 viewPos; 52 | uniform DirLight dirLight; 53 | uniform PointLight pointLights[NR_POINT_LIGHTS]; 54 | uniform SpotLight spotLight; 55 | uniform Material material; 56 | 57 | // function prototypes 58 | vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir); 59 | vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir); 60 | vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir); 61 | 62 | void main() 63 | { 64 | // properties 65 | vec3 norm = normalize(Normal); 66 | vec3 viewDir = normalize(viewPos - FragPos); 67 | 68 | // == ===================================================== 69 | // Our lighting is set up in 3 phases: directional, point lights and an optional flashlight 70 | // For each phase, a calculate function is defined that calculates the corresponding color 71 | // per lamp. In the main() function we take all the calculated colors and sum them up for 72 | // this fragment's final color. 73 | // == ===================================================== 74 | // phase 1: directional lighting 75 | vec3 result = CalcDirLight(dirLight, norm, viewDir); 76 | // phase 2: point lights 77 | for(int i = 0; i < NR_POINT_LIGHTS; i++) 78 | result += CalcPointLight(pointLights[i], norm, FragPos, viewDir); 79 | // phase 3: spot light 80 | result += CalcSpotLight(spotLight, norm, FragPos, viewDir); 81 | 82 | FragColor = vec4(result, 1.0); 83 | } 84 | 85 | // calculates the color when using a directional light. 86 | vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir) 87 | { 88 | vec3 lightDir = normalize(-light.direction); 89 | // diffuse shading 90 | float diff = max(dot(normal, lightDir), 0.0); 91 | // specular shading 92 | vec3 reflectDir = reflect(-lightDir, normal); 93 | float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); 94 | // combine results 95 | vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); 96 | vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords)); 97 | vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); 98 | return (ambient + diffuse + specular); 99 | } 100 | 101 | // calculates the color when using a point light. 102 | vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir) 103 | { 104 | vec3 lightDir = normalize(light.position - fragPos); 105 | // diffuse shading 106 | float diff = max(dot(normal, lightDir), 0.0); 107 | // specular shading 108 | vec3 reflectDir = reflect(-lightDir, normal); 109 | float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); 110 | // attenuation 111 | float distance = length(light.position - fragPos); 112 | float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance)); 113 | // combine results 114 | vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); 115 | vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords)); 116 | vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); 117 | ambient *= attenuation; 118 | diffuse *= attenuation; 119 | specular *= attenuation; 120 | return (ambient + diffuse + specular); 121 | } 122 | 123 | // calculates the color when using a spot light. 124 | vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir) 125 | { 126 | vec3 lightDir = normalize(light.position - fragPos); 127 | // diffuse shading 128 | float diff = max(dot(normal, lightDir), 0.0); 129 | // specular shading 130 | vec3 reflectDir = reflect(-lightDir, normal); 131 | float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess); 132 | // attenuation 133 | float distance = length(light.position - fragPos); 134 | float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance)); 135 | // spotlight intensity 136 | float theta = dot(lightDir, normalize(-light.direction)); 137 | float epsilon = light.cutOff - light.outerCutOff; 138 | float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0); 139 | // combine results 140 | vec3 ambient = light.ambient * vec3(texture(material.diffuse, TexCoords)); 141 | vec3 diffuse = light.diffuse * diff * vec3(texture(material.diffuse, TexCoords)); 142 | vec3 specular = light.specular * spec * vec3(texture(material.specular, TexCoords)); 143 | ambient *= attenuation * intensity; 144 | diffuse *= attenuation * intensity; 145 | specular *= attenuation * intensity; 146 | return (ambient + diffuse + specular); 147 | } -------------------------------------------------------------------------------- /specular.vs: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec3 aPos; 3 | layout (location = 1) in vec3 aNormal; 4 | layout (location = 2) in vec2 aTexCoords; 5 | 6 | out vec3 FragPos; 7 | out vec3 Normal; 8 | out vec2 TexCoords; 9 | 10 | uniform mat4 model; 11 | uniform mat4 view; 12 | uniform mat4 projection; 13 | 14 | void main() 15 | { 16 | FragPos = vec3(model * vec4(aPos, 1.0)); 17 | Normal = mat3(transpose(inverse(model))) * aNormal; 18 | TexCoords = aTexCoords; 19 | 20 | gl_Position = projection * view * vec4(FragPos, 1.0); 21 | } -------------------------------------------------------------------------------- /text.fs: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | in vec2 TexCoords; 3 | out vec4 color; 4 | 5 | uniform sampler2D text; 6 | uniform vec3 textColor; 7 | 8 | void main() 9 | { 10 | vec4 sampled = vec4(1.0, 1.0, 1.0, texture(text, TexCoords).r); 11 | color = vec4(textColor, 1.0) * sampled; 12 | } -------------------------------------------------------------------------------- /text.vs: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | layout (location = 0) in vec4 vertex; // 3 | out vec2 TexCoords; 4 | 5 | uniform mat4 projection; 6 | 7 | void main() 8 | { 9 | gl_Position = projection * vec4(vertex.xy, 0.0, 1.0); 10 | TexCoords = vertex.zw; 11 | } -------------------------------------------------------------------------------- /vc140.pdb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sheraadams/OpenGL-Text-Rendering-and-Animation/3c4dfd3331a4973faf778d92d147c343b46c378b/vc140.pdb --------------------------------------------------------------------------------