├── .gitignore
├── images
    ├── demo.gif
    └── logo.png
├── DearImXML
    ├── src
    │   ├── XMLDynamicBind.h
    │   ├── ImGuiEnum.h
    │   ├── XMLEventHandler.h
    │   ├── XMLTree.h
    │   ├── main.cpp
    │   ├── XMLRenderer.h
    │   └── XMLReader.h
    └── Assets
    │   └── test.xml
├── tools
    └── flags_mapper.py
├── includes
    ├── ImGUI
    │   ├── imgui_stdlib.h
    │   ├── imgui_stdlib.cpp
    │   ├── imgui_impl_opengl3.h
    │   ├── imgui_impl_glfw.h
    │   ├── imconfig.h
    │   ├── imstb_rectpack.h
    │   └── imgui_impl_opengl3_loader.h
    ├── KHR
    │   └── khrplatform.h
    └── GL
    │   └── gl3w.c
├── CMakeLists.txt
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | build/
2 | libs/
3 | .vscode/
4 | 
5 | *.raw
6 | 


--------------------------------------------------------------------------------
/images/demo.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ProtectedVariable/DearImXML/HEAD/images/demo.gif


--------------------------------------------------------------------------------
/images/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ProtectedVariable/DearImXML/HEAD/images/logo.png


--------------------------------------------------------------------------------
/DearImXML/src/XMLDynamicBind.h:
--------------------------------------------------------------------------------
 1 | #ifndef DEARIMXML_XMLDYNAMICBIND_H
 2 | #define DEARIMXML_XMLDYNAMICBIND_H
 3 | 
 4 | namespace ImXML {
 5 | 
 6 | 	enum XMLDynamicBindType {
 7 | 		Float, Int, Chars,
 8 | 	};
 9 | 
10 | 	struct XMLDynamicBind
11 | 	{
12 | 		void* ptr;
13 | 		unsigned int size;
14 | 		XMLDynamicBindType type;
15 | 	};
16 | 	
17 | 	
18 | }
19 | 
20 | #endif /* DEARIMXML_XMLDYNAMICBIND_H */
21 | 


--------------------------------------------------------------------------------
/DearImXML/src/ImGuiEnum.h:
--------------------------------------------------------------------------------
 1 | #ifndef IMGUIENUM_H
 2 | #define IMGUIENUM_H
 3 | 
 4 | namespace ImXML {
 5 | 	enum ImGuiEnum {
 6 | 		BEGIN, PLACEHOLDER, BUTTON, TEXT, SAMELINE, MENUBAR, MENU, MENUITEM, SLIDERFLOAT, INPUTTEXT, 
 7 | 		TREENODE, TREE, COLUMNS, COLUMN, GROUP, COLORPICKER3, COLORPICKER4, COLOREDIT3, COLOREDIT4,
 8 | 		POPUPCONTEXTWINDOW, SEPARATOR,
 9 | 	};
10 | }
11 | 
12 | #endif /* IMGUIENUM_H */
13 | 


--------------------------------------------------------------------------------
/tools/flags_mapper.py:
--------------------------------------------------------------------------------
 1 | import fileinput
 2 | import io
 3 | 
 4 | if __name__ == "__main__":
 5 | 	f = open("enum.raw")
 6 | 	for line in f.readlines():
 7 | 		enum_entry = line.split("=")[0].strip()
 8 | 		if not (enum_entry.startswith("//") or len(enum_entry) == 0 or enum_entry.startswith("{") or enum_entry.startswith("}")):
 9 | 			if enum_entry.startswith("enum "):
10 | 				print("//"+enum_entry)
11 | 			else:
12 | 				print('{ "'+enum_entry+'", '+enum_entry+' },')
13 | 


--------------------------------------------------------------------------------
/DearImXML/src/XMLEventHandler.h:
--------------------------------------------------------------------------------
 1 | #ifndef DEARIMXML_XMLEVENTHANDLER_H
 2 | #define DEARIMXML_XMLEVENTHANDLER_H
 3 | 
 4 | #include <XMLTree.h>
 5 | 
 6 | namespace ImXML {
 7 | 	class XMLEventHandler
 8 | 	{
 9 | 	public:
10 | 		XMLEventHandler(/* args */);
11 | 		~XMLEventHandler();
12 | 
13 | 		virtual void onNodeBegin(XMLNode& node) = 0;
14 | 		virtual void onNodeEnd(XMLNode& node) = 0;
15 | 		virtual void onEvent(XMLNode& node) = 0;
16 | 
17 | 	};
18 | 	
19 | 	XMLEventHandler::XMLEventHandler(/* args */)
20 | 	{
21 | 	}
22 | 	
23 | 	XMLEventHandler::~XMLEventHandler()
24 | 	{
25 | 	}
26 | 	
27 | }
28 | 
29 | #endif /* DEARIMXML_XMLEVENTHANDLER_H */
30 | 


--------------------------------------------------------------------------------
/DearImXML/src/XMLTree.h:
--------------------------------------------------------------------------------
 1 | #ifndef DEARIMXML_XMLTREE_H
 2 | #define DEARIMXML_XMLTREE_H
 3 | 
 4 | #include <ImGuiEnum.h>
 5 | #include <unordered_map>
 6 | #include <string>
 7 | #include <vector>
 8 | 
 9 | namespace ImXML {
10 | 
11 | 	struct XMLNode
12 | 	{
13 | 		ImGuiEnum type;
14 | 		std::unordered_map<std::string, std::string> args;
15 | 		int flags = 0;
16 | 		std::vector<XMLNode*> children;
17 | 	};
18 | 	
19 | 
20 | 	class XMLTree
21 | 	{
22 | 	private:
23 | 		XMLNode root;
24 | 	public:
25 | 		XMLTree(XMLNode root);
26 | 		~XMLTree();
27 | 
28 | 		XMLNode& getRoot() {
29 | 			return root;
30 | 		}
31 | 	};
32 | 	
33 | 	XMLTree::XMLTree(XMLNode root) : root(root)
34 | 	{
35 | 	}
36 | 	
37 | 	XMLTree::~XMLTree()
38 | 	{
39 | 	}
40 | 	
41 | }
42 | 
43 | #endif /* DEARIMXML_XMLTREE_H */
44 | 


--------------------------------------------------------------------------------
/DearImXML/Assets/test.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | 
 3 | <begin name="Title window" flags="ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoCollapse">
 4 | 	<columns count="2"/>
 5 | 	<menubar>
 6 | 		<menu label="File">
 7 | 			<menuitem label="New..."/>
 8 | 			<menu label="Open...">
 9 | 				<menuitem label="File1.txt" />
10 | 			</menu>
11 | 		</menu>
12 | 		<menu label="Edit">
13 | 			<menuitem label="Foo"/>
14 | 			<menuitem label="Bar"/>
15 | 		</menu>
16 | 	</menubar>
17 | 	<column>
18 | 		<sameline>
19 | 			<text label="Text"/>
20 | 			<button id="btn0" label="Hello!"/>
21 | 		</sameline>
22 | 		<text label="new line"/>
23 | 		<sliderfloat label="float" dynamic="float0" min="0" max="1" />
24 | 		<inputtext label="string" dynamic="str0"/>
25 | 		<placeholder id="custom0"/>
26 | 	</column>
27 | 	<column>
28 | 		<tree>
29 | 			<treenode label="treeroot">
30 | 				<treenode label="tree0" />
31 | 				<treenode label="tree1">
32 | 					<treenode label="tree2" />
33 | 				</treenode>
34 | 			</treenode>
35 | 		</tree>
36 | 		<group>
37 | 			<colorpicker3 dynamic="color0" />
38 | 		</group>
39 | 		<separator/>
40 | 		<group>
41 | 			<PopupContextWindow>
42 | 				<text label="context popup"/>
43 | 			</PopupContextWindow>
44 | 			<text label="right click to open popup"/>
45 | 		</group>
46 | 	</column>
47 | </begin>
48 | 


--------------------------------------------------------------------------------
/includes/ImGUI/imgui_stdlib.h:
--------------------------------------------------------------------------------
 1 | // dear imgui: wrappers for C++ standard library (STL) types (std::string, etc.)
 2 | // This is also an example of how you may wrap your own similar types.
 3 | 
 4 | // Changelog:
 5 | // - v0.10: Initial version. Added InputText() / InputTextMultiline() calls with std::string
 6 | 
 7 | // See more C++ related extension (fmt, RAII, syntaxis sugar) on Wiki:
 8 | //   https://github.com/ocornut/imgui/wiki/Useful-Extensions#cness
 9 | 
10 | #ifndef IMGUI_STDLIB_H
11 | #define IMGUI_STDLIB_H
12 | 
13 | 
14 | #include <string>
15 | 
16 | namespace ImGui
17 | {
18 |     // ImGui::InputText() with std::string
19 |     // Because text input needs dynamic resizing, we need to setup a callback to grow the capacity
20 |     IMGUI_API bool  InputText(const char* label, std::string* str, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr);
21 |     IMGUI_API bool  InputTextMultiline(const char* label, std::string* str, const ImVec2& size = ImVec2(0, 0), ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr);
22 |     IMGUI_API bool  InputTextWithHint(const char* label, const char* hint, std::string* str, ImGuiInputTextFlags flags = 0, ImGuiInputTextCallback callback = nullptr, void* user_data = nullptr);
23 | }
24 | 
25 | 
26 | #endif /* IMGUI_STDLIB_H */
27 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.17)
 2 | project(DearImXML)
 3 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
 4 | set(CMAKE_CXX_STANDARD 17)
 5 | set(GLFW_LIB_PATH "${CMAKE_CURRENT_SOURCE_DIR}/libs/glfw/")
 6 | 
 7 | message(STATUS "Bulding ${PROJECT_NAME}")
 8 | 
 9 | set(GLFW_INSTALL OFF CACHE BOOL "" FORCE)
10 | set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
11 | set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
12 | set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
13 | 
14 | 
15 | include(FetchContent)
16 | FetchContent_Declare(
17 |   GLFW
18 |   GIT_REPOSITORY https://github.com/glfw/glfw.git
19 |   GIT_TAG master
20 | )
21 | FetchContent_MakeAvailable(GLFW)
22 | 
23 | 
24 | include_directories(includes)
25 | include_directories(DearImXML/src)
26 | 
27 | set(SRC 
28 | 	includes/GL/gl3w.c
29 | 	includes/ImGUI/imgui_impl_glfw.cpp
30 | 	includes/ImGUI/imgui_impl_opengl3.cpp
31 | 	includes/ImGUI/imgui.cpp
32 | 	includes/ImGUI/imgui_widgets.cpp
33 | 	includes/ImGUI/imgui_draw.cpp
34 | 	includes/ImGUI/imgui_tables.cpp
35 | 
36 | 	DearImXML/src/ImGuiEnum.h
37 | 	DearImXML/src/XMLReader.h
38 | 	DearImXML/src/XMLTree.h
39 | 	DearImXML/src/XMLRenderer.h
40 | 	DearImXML/src/XMLEventHandler.h
41 | )
42 | 		
43 | add_library(DearImXML STATIC "${SRC}")
44 | add_executable(DearImXMLTest DearImXML/src/main.cpp)
45 | target_link_libraries(DearImXMLTest DearImXML)
46 | target_include_directories(${PROJECT_NAME} PUBLIC
47 |         $<INSTALL_INTERFACE:include>
48 |         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/DearImXML/src>
49 |         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/includes>
50 | )
51 | file(COPY DearImXML/Assets DESTINATION ${CMAKE_BINARY_DIR})
52 | 
53 | if(APPLE)
54 | 	enable_testing()
55 | 	find_package(GTest REQUIRED)
56 | 	include_directories(${GTEST_INCLUDE_DIRS})
57 | 	target_link_libraries(DearImXML glfw ${COCOA_LIBRARY} ${OPENGL_LIBRARY} ${IOKIT_LIBRARY})
58 | elseif(WIN32)
59 | 	target_link_libraries(DearImXML glfw)
60 | else()
61 | 	enable_testing()
62 | 	find_package(GTest REQUIRED)
63 | 	include_directories(${GTEST_INCLUDE_DIRS})
64 | 	find_package(PkgConfig REQUIRED)
65 | 	pkg_check_modules(GTK3 REQUIRED gtk+-3.0)
66 | 
67 | 	include_directories(${GTK3_INCLUDE_DIRS})
68 | 	link_directories(${GTK3_LIBRARY_DIRS})
69 | 
70 | 	add_definitions(${GTK3_CFLAGS_OTHER})
71 | 
72 | 	find_package(OpenGL REQUIRED)
73 | 	include_directories(${OPENGL_INCLUDE_DIRS})
74 | 
75 | 	target_link_libraries(DearImXML glfw ${GTK3_LIBRARIES} ${OPENGL_LIBRARIES} stdc++fs)
76 | endif()


--------------------------------------------------------------------------------
/includes/ImGUI/imgui_stdlib.cpp:
--------------------------------------------------------------------------------
 1 | // dear imgui: wrappers for C++ standard library (STL) types (std::string, etc.)
 2 | // This is also an example of how you may wrap your own similar types.
 3 | 
 4 | // Changelog:
 5 | // - v0.10: Initial version. Added InputText() / InputTextMultiline() calls with std::string
 6 | 
 7 | // See more C++ related extension (fmt, RAII, syntaxis sugar) on Wiki:
 8 | //   https://github.com/ocornut/imgui/wiki/Useful-Extensions#cness
 9 | 
10 | #include "imgui.h"
11 | #include "imgui_stdlib.h"
12 | 
13 | // Clang warnings with -Weverything
14 | #if defined(__clang__)
15 | #pragma clang diagnostic push
16 | #pragma clang diagnostic ignored "-Wsign-conversion"    // warning: implicit conversion changes signedness
17 | #endif
18 | 
19 | struct InputTextCallback_UserData
20 | {
21 |     std::string*            Str;
22 |     ImGuiInputTextCallback  ChainCallback;
23 |     void*                   ChainCallbackUserData;
24 | };
25 | 
26 | static int InputTextCallback(ImGuiInputTextCallbackData* data)
27 | {
28 |     InputTextCallback_UserData* user_data = (InputTextCallback_UserData*)data->UserData;
29 |     if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
30 |     {
31 |         // Resize string callback
32 |         // If for some reason we refuse the new length (BufTextLen) and/or capacity (BufSize) we need to set them back to what we want.
33 |         std::string* str = user_data->Str;
34 |         IM_ASSERT(data->Buf == str->c_str());
35 |         str->resize(data->BufTextLen);
36 |         data->Buf = (char*)str->c_str();
37 |     }
38 |     else if (user_data->ChainCallback)
39 |     {
40 |         // Forward to user callback, if any
41 |         data->UserData = user_data->ChainCallbackUserData;
42 |         return user_data->ChainCallback(data);
43 |     }
44 |     return 0;
45 | }
46 | 
47 | bool ImGui::InputText(const char* label, std::string* str, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
48 | {
49 |     IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
50 |     flags |= ImGuiInputTextFlags_CallbackResize;
51 | 
52 |     InputTextCallback_UserData cb_user_data;
53 |     cb_user_data.Str = str;
54 |     cb_user_data.ChainCallback = callback;
55 |     cb_user_data.ChainCallbackUserData = user_data;
56 |     return InputText(label, (char*)str->c_str(), str->capacity() + 1, flags, InputTextCallback, &cb_user_data);
57 | }
58 | 
59 | bool ImGui::InputTextMultiline(const char* label, std::string* str, const ImVec2& size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
60 | {
61 |     IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
62 |     flags |= ImGuiInputTextFlags_CallbackResize;
63 | 
64 |     InputTextCallback_UserData cb_user_data;
65 |     cb_user_data.Str = str;
66 |     cb_user_data.ChainCallback = callback;
67 |     cb_user_data.ChainCallbackUserData = user_data;
68 |     return InputTextMultiline(label, (char*)str->c_str(), str->capacity() + 1, size, flags, InputTextCallback, &cb_user_data);
69 | }
70 | 
71 | bool ImGui::InputTextWithHint(const char* label, const char* hint, std::string* str, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
72 | {
73 |     IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
74 |     flags |= ImGuiInputTextFlags_CallbackResize;
75 | 
76 |     InputTextCallback_UserData cb_user_data;
77 |     cb_user_data.Str = str;
78 |     cb_user_data.ChainCallback = callback;
79 |     cb_user_data.ChainCallbackUserData = user_data;
80 |     return InputTextWithHint(label, hint, (char*)str->c_str(), str->capacity() + 1, flags, InputTextCallback, &cb_user_data);
81 | }
82 | 
83 | #if defined(__clang__)
84 | #pragma clang diagnostic pop
85 | #endif
86 | 


--------------------------------------------------------------------------------
/includes/ImGUI/imgui_impl_opengl3.h:
--------------------------------------------------------------------------------
 1 | // dear imgui: Renderer Backend for modern OpenGL with shaders / programmatic pipeline
 2 | // - Desktop GL: 2.x 3.x 4.x
 3 | // - Embedded GL: ES 2.0 (WebGL 1.0), ES 3.0 (WebGL 2.0)
 4 | // This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
 5 | 
 6 | // Implemented features:
 7 | //  [X] Renderer: User texture binding. Use 'GLuint' OpenGL texture identifier as void*/ImTextureID. Read the FAQ about ImTextureID!
 8 | //  [X] Renderer: Large meshes support (64k+ vertices) with 16-bit indices (Desktop OpenGL only).
 9 | //  [X] Renderer: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
10 | 
11 | // About WebGL/ES:
12 | // - You need to '#define IMGUI_IMPL_OPENGL_ES2' or '#define IMGUI_IMPL_OPENGL_ES3' to use WebGL or OpenGL ES.
13 | // - This is done automatically on iOS, Android and Emscripten targets.
14 | // - For other targets, the define needs to be visible from the imgui_impl_opengl3.cpp compilation unit. If unsure, define globally or in imconfig.h.
15 | 
16 | // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
17 | // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
18 | // Learn about Dear ImGui:
19 | // - FAQ                  https://dearimgui.com/faq
20 | // - Getting Started      https://dearimgui.com/getting-started
21 | // - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
22 | // - Introduction, links and more at the top of imgui.cpp
23 | 
24 | // About GLSL version:
25 | //  The 'glsl_version' initialization parameter should be nullptr (default) or a "#version XXX" string.
26 | //  On computer platform the GLSL version default to "#version 130". On OpenGL ES 3 platform it defaults to "#version 300 es"
27 | //  Only override if your GL version doesn't handle this GLSL version. See GLSL version table at the top of imgui_impl_opengl3.cpp.
28 | 
29 | #ifndef IMGUI_IMPL_OPENGL3_H
30 | #define IMGUI_IMPL_OPENGL3_H
31 | 
32 | #include "imgui.h"      // IMGUI_IMPL_API
33 | #ifndef IMGUI_DISABLE
34 | 
35 | // Backend API
36 | IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_Init(const char* glsl_version = nullptr);
37 | IMGUI_IMPL_API void     ImGui_ImplOpenGL3_Shutdown();
38 | IMGUI_IMPL_API void     ImGui_ImplOpenGL3_NewFrame();
39 | IMGUI_IMPL_API void     ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data);
40 | 
41 | // (Optional) Called by Init/NewFrame/Shutdown
42 | IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_CreateFontsTexture();
43 | IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyFontsTexture();
44 | IMGUI_IMPL_API bool     ImGui_ImplOpenGL3_CreateDeviceObjects();
45 | IMGUI_IMPL_API void     ImGui_ImplOpenGL3_DestroyDeviceObjects();
46 | 
47 | // Specific OpenGL ES versions
48 | //#define IMGUI_IMPL_OPENGL_ES2     // Auto-detected on Emscripten
49 | //#define IMGUI_IMPL_OPENGL_ES3     // Auto-detected on iOS/Android
50 | 
51 | // You can explicitly select GLES2 or GLES3 API by using one of the '#define IMGUI_IMPL_OPENGL_LOADER_XXX' in imconfig.h or compiler command-line.
52 | #if !defined(IMGUI_IMPL_OPENGL_ES2) \
53 |  && !defined(IMGUI_IMPL_OPENGL_ES3)
54 | 
55 | // Try to detect GLES on matching platforms
56 | #if defined(__APPLE__)
57 | #include <TargetConditionals.h>
58 | #endif
59 | #if (defined(__APPLE__) && (TARGET_OS_IOS || TARGET_OS_TV)) || (defined(__ANDROID__))
60 | #define IMGUI_IMPL_OPENGL_ES3               // iOS, Android  -> GL ES 3, "#version 300 es"
61 | #elif defined(__EMSCRIPTEN__) || defined(__amigaos4__)
62 | #define IMGUI_IMPL_OPENGL_ES2               // Emscripten    -> GL ES 2, "#version 100"
63 | #else
64 | // Otherwise imgui_impl_opengl3_loader.h will be used.
65 | #endif
66 | 
67 | #endif
68 | 
69 | #endif // #ifndef IMGUI_DISABLE
70 | 
71 | 
72 | #endif /* IMGUI_IMPL_OPENGL3_H */
73 | 


--------------------------------------------------------------------------------
/DearImXML/src/main.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | #include <GL/gl3w.h>            // Initialize with gl3wInit()
  3 | // Include glfw3.h after our OpenGL definitions
  4 | #include <GLFW/glfw3.h>
  5 | #include <ImGUI/imgui.h>
  6 | #include <ImGUI/imgui_internal.h>
  7 | #include <ImGUI/imgui_impl_glfw.h>
  8 | #include <ImGUI/imgui_impl_opengl3.h>
  9 | 
 10 | #include <string>
 11 | #include <iostream>
 12 | #include <fstream>
 13 | 
 14 | #include <XMLReader.h>
 15 | #include <XMLTree.h>
 16 | #include <XMLRenderer.h>
 17 | #include <XMLEventHandler.h>
 18 | #include <XMLDynamicBind.h>
 19 | 
 20 | class Handler : public ImXML::XMLEventHandler {
 21 |     virtual void onNodeBegin(ImXML::XMLNode& node) override {
 22 | 
 23 |     }
 24 |     
 25 |     virtual void onNodeEnd(ImXML::XMLNode& node) override {
 26 | 
 27 |     }
 28 | 
 29 |     virtual void onEvent(ImXML::XMLNode& node) override {
 30 |         if(node.args["id"] == "btn0") {
 31 |             node.args["label"] = "Clicked";
 32 |         }
 33 |     }
 34 | 
 35 | };
 36 | 
 37 | int main(int argc, char const *argv[])
 38 | {
 39 | 	if (!glfwInit())
 40 |     	return 1;
 41 | 
 42 |     // Decide GL+GLSL versions
 43 | #ifdef __APPLE__
 44 |     // GL 3.2 + GLSL 150
 45 |     const char* glsl_version = "#version 330 core";
 46 |     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
 47 |     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
 48 |     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // 3.2+ only
 49 |     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);            // Required on Mac
 50 | #else
 51 |     // GL 3.0 + GLSL 130
 52 |     const char* glsl_version = "#version 330 core";
 53 |     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
 54 |     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
 55 |     glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);  // 3.2+ only
 56 |     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);            // 3.0+ only
 57 | #endif
 58 |     // Create window with graphics context
 59 |     GLFWwindow* window = glfwCreateWindow(1280, 720, "ICE Engine", NULL, NULL);
 60 |     if (window == NULL)
 61 |         return 1;
 62 |     glfwMakeContextCurrent(window);
 63 |     glfwSwapInterval(1); // Enable vsync
 64 | 
 65 |     bool err = gl3wInit();
 66 | 
 67 | 	IMGUI_CHECKVERSION();
 68 |     ImGui::CreateContext();
 69 |     ImGuiIO& io = ImGui::GetIO(); (void)io;
 70 |     io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;       // Enable Keyboard Controls
 71 |     //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
 72 |     //io.ConfigViewportsNoAutoMerge = true;
 73 |     //io.ConfigViewportsNoTaskBarIcon = true;
 74 | 	ImGui_ImplGlfw_InitForOpenGL(window, true);
 75 |     ImGui_ImplOpenGL3_Init(glsl_version);
 76 | 
 77 | 	ImXML::XMLReader reader = ImXML::XMLReader();
 78 | 	ImXML::XMLTree tree = reader.read("Assets/test.xml");
 79 |     ImXML::XMLRenderer renderer;
 80 |     float float0;
 81 |     char buf[512] = {0};
 82 |     float color0[3] = {0};
 83 |     float color1[4] = {0};
 84 |     renderer.addDynamicBind(std::string("float0"), {.ptr = &float0});
 85 |     renderer.addDynamicBind(std::string("str0"), {.ptr = buf, .size=512});
 86 |     renderer.addDynamicBind(std::string("color0"), {.ptr = color0});
 87 |     renderer.addDynamicBind(std::string("color1"), {.ptr = color1});
 88 |     Handler handler;
 89 | 
 90 | 	while (!glfwWindowShouldClose(window))
 91 |     {
 92 |         IM_ASSERT(ImGui::GetCurrentContext() != NULL && "Missing dear imgui context. Refer to examples app!");
 93 |         glfwPollEvents();
 94 | 
 95 |         ImGui_ImplOpenGL3_NewFrame();
 96 |         ImGui_ImplGlfw_NewFrame();
 97 |         ImGui::NewFrame();
 98 | 
 99 |         glClearColor(0.45f, 0.55f, 0.60f, 1.00f);
100 |         glClear(GL_COLOR_BUFFER_BIT);
101 | 
102 |         // render your GUI
103 |         renderer.render(tree, handler);
104 | 
105 |         // Render dear imgui into screen
106 |         ImGui::Render();
107 | 
108 |         int display_w, display_h;
109 |         glfwGetFramebufferSize(window, &display_w, &display_h);
110 |         glViewport(0, 0, display_w, display_h);
111 |         ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
112 |         glfwSwapBuffers(window);
113 |     }
114 |     
115 | 	return 0;
116 | }
117 | 


--------------------------------------------------------------------------------
/includes/ImGUI/imgui_impl_glfw.h:
--------------------------------------------------------------------------------
 1 | // dear imgui: Platform Backend for GLFW
 2 | // This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
 3 | // (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
 4 | // (Requires: GLFW 3.1+. Prefer GLFW 3.3+ for full feature support.)
 5 | 
 6 | // Implemented features:
 7 | //  [X] Platform: Clipboard support.
 8 | //  [X] Platform: Mouse support. Can discriminate Mouse/TouchScreen/Pen (Windows only).
 9 | //  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
10 | //  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
11 | //  [x] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
12 | //  [X] Platform: Multi-viewport support (multiple windows). Enable with 'io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable'.
13 | 
14 | // Issues:
15 | //  [ ] Platform: Multi-viewport support: ParentViewportID not honored, and so io.ConfigViewportsNoDefaultParent has no effect (minor).
16 | 
17 | // You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
18 | // Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
19 | // Learn about Dear ImGui:
20 | // - FAQ                  https://dearimgui.com/faq
21 | // - Getting Started      https://dearimgui.com/getting-started
22 | // - Documentation        https://dearimgui.com/docs (same as your local docs/ folder).
23 | // - Introduction, links and more at the top of imgui.cpp
24 | 
25 | #ifndef IMGUI_IMPL_GLFW_H
26 | #define IMGUI_IMPL_GLFW_H
27 | 
28 | #include "imgui.h"      // IMGUI_IMPL_API
29 | #ifndef IMGUI_DISABLE
30 | 
31 | struct GLFWwindow;
32 | struct GLFWmonitor;
33 | 
34 | IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks);
35 | IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks);
36 | IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks);
37 | IMGUI_IMPL_API void     ImGui_ImplGlfw_Shutdown();
38 | IMGUI_IMPL_API void     ImGui_ImplGlfw_NewFrame();
39 | 
40 | // GLFW callbacks install
41 | // - When calling Init with 'install_callbacks=true': ImGui_ImplGlfw_InstallCallbacks() is called. GLFW callbacks will be installed for you. They will chain-call user's previously installed callbacks, if any.
42 | // - When calling Init with 'install_callbacks=false': GLFW callbacks won't be installed. You will need to call individual function yourself from your own GLFW callbacks.
43 | IMGUI_IMPL_API void     ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
44 | IMGUI_IMPL_API void     ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
45 | 
46 | // GFLW callbacks options:
47 | // - Set 'chain_for_all_windows=true' to enable chaining callbacks for all windows (including secondary viewports created by backends or by user)
48 | IMGUI_IMPL_API void     ImGui_ImplGlfw_SetCallbacksChainForAllWindows(bool chain_for_all_windows);
49 | 
50 | // GLFW callbacks (individual callbacks to call yourself if you didn't install callbacks)
51 | IMGUI_IMPL_API void     ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused);        // Since 1.84
52 | IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered);        // Since 1.84
53 | IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y);   // Since 1.87
54 | IMGUI_IMPL_API void     ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
55 | IMGUI_IMPL_API void     ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
56 | IMGUI_IMPL_API void     ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
57 | IMGUI_IMPL_API void     ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);
58 | IMGUI_IMPL_API void     ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor, int event);
59 | 
60 | #endif // #ifndef IMGUI_DISABLE
61 | 
62 | 
63 | #endif /* IMGUI_IMPL_GLFW_H */
64 | 


--------------------------------------------------------------------------------
/DearImXML/src/XMLRenderer.h:
--------------------------------------------------------------------------------
  1 | #ifndef XMLRENDERER_H
  2 | #define XMLRENDERER_H
  3 | 
  4 | #include <XMLTree.h>
  5 | #include <XMLEventHandler.h>
  6 | #include <XMLDynamicBind.h>
  7 | #include <ImGUI/imgui.h>
  8 | #include <unordered_map>
  9 | 
 10 | namespace ImXML {
 11 | 	class XMLRenderer
 12 | 	{
 13 | 	private:
 14 | 		int sameline = 0;
 15 | 		bool popup = false;
 16 | 		std::unordered_map<std::string, XMLDynamicBind> dynamicBinds;
 17 | 
 18 | 		void renderMenu(XMLNode& node, XMLEventHandler& handler) {
 19 | 			if(node.type == ImGuiEnum::MENU) {
 20 | 				if(ImGui::BeginMenu(node.args["label"].c_str())) {
 21 | 					for(auto child : node.children) {
 22 | 						if(child->type == ImGuiEnum::MENUITEM) {
 23 | 							if(ImGui::MenuItem(child->args["label"].c_str())) {
 24 | 								handler.onEvent(*child);
 25 | 							}
 26 | 						} else if(child->type == ImGuiEnum::MENU) {
 27 | 							renderMenu(*child, handler);
 28 | 						}
 29 | 					}
 30 | 					ImGui::EndMenu();
 31 | 				}
 32 | 			}
 33 | 		}
 34 | 
 35 | 		void renderTree(XMLNode& node, XMLEventHandler& handler) {
 36 | 			if(node.type == ImGuiEnum::TREENODE) {
 37 | 				if(ImGui::TreeNode(node.args["label"].c_str())) {
 38 | 					handler.onEvent(node);
 39 | 					for(auto child : node.children) {
 40 | 						renderTree(*child, handler);
 41 | 					}
 42 | 					ImGui::TreePop();
 43 | 				}
 44 | 			} else if(node.type == ImGuiEnum::TREE) {
 45 | 				for(auto child : node.children) {
 46 | 					renderTree(*child, handler);
 47 | 				}
 48 | 			} else {
 49 | 				onNodeBegin(node, handler);
 50 | 			}
 51 | 		}
 52 | 
 53 | 		void onNodeBegin(XMLNode& node, XMLEventHandler& handler, bool inPopup=false) {
 54 | 			handler.onNodeBegin(node);
 55 | 			if(!inPopup && popup) {
 56 | 				return;
 57 | 			}
 58 | 			
 59 | 			if(sameline == 1) {
 60 | 				sameline++;
 61 | 			} else if(sameline == 2) {
 62 | 				ImGui::SameLine();
 63 | 			}
 64 | 
 65 | 			if(node.type == ImGuiEnum::COLUMNS) {
 66 | 				ImGui::Columns(std::stoi(node.args["count"]));
 67 | 			}
 68 | 
 69 | 			if(node.type == ImGuiEnum::MENUBAR) {
 70 | 				if(ImGui::BeginMenuBar()) {
 71 | 					for(auto child : node.children) {
 72 | 						renderMenu(*child, handler);
 73 | 					}
 74 | 					ImGui::EndMenuBar();
 75 | 				}
 76 | 			}
 77 | 			
 78 | 			if(node.type == ImGuiEnum::BEGIN) {
 79 | 				ImGui::Begin(node.args["name"].c_str(), nullptr, node.flags);
 80 | 			}
 81 | 
 82 | 			if(node.type == ImGuiEnum::GROUP) {
 83 | 				ImGui::BeginGroup();
 84 | 			}
 85 | 
 86 | 			if(node.type == ImGuiEnum::POPUPCONTEXTWINDOW) {
 87 | 				popup = true;
 88 | 				if(ImGui::BeginPopupContextWindow()) {
 89 | 					for(auto child : node.children) {
 90 | 						traverse(*child, handler, true);
 91 | 					}
 92 | 					ImGui::EndPopup();
 93 | 				}
 94 | 			}
 95 | 
 96 | 			if(node.type == ImGuiEnum::COLORPICKER3) {
 97 | 				ImGui::ColorPicker3(node.args["label"].c_str(), (float*)dynamicBinds.at(node.args["dynamic"]).ptr);
 98 | 			}
 99 | 			if(node.type == ImGuiEnum::COLORPICKER4) {
100 | 				ImGui::ColorPicker4(node.args["label"].c_str(), (float*)dynamicBinds.at(node.args["dynamic"]).ptr);
101 | 			}
102 | 			if(node.type == ImGuiEnum::COLOREDIT3) {
103 | 				ImGui::ColorEdit3(node.args["label"].c_str(), (float*)dynamicBinds.at(node.args["dynamic"]).ptr);
104 | 			}
105 | 			if(node.type == ImGuiEnum::COLOREDIT4) {
106 | 				ImGui::ColorEdit4(node.args["label"].c_str(), (float*)dynamicBinds.at(node.args["dynamic"]).ptr);
107 | 			}
108 | 
109 | 			if(node.type == ImGuiEnum::BUTTON) {
110 | 				if(ImGui::Button(node.args["label"].c_str())) {
111 | 					handler.onEvent(node);
112 | 				}
113 | 			}
114 | 
115 | 			if(node.type == ImGuiEnum::TEXT) {
116 | 				ImGui::Text("%s", node.args["label"].c_str());
117 | 			}
118 | 
119 | 			if(node.type == ImGuiEnum::SLIDERFLOAT) {
120 | 				ImGui::SliderFloat(node.args["label"].c_str(), (float*)dynamicBinds.at(node.args["dynamic"]).ptr, std::stof(node.args["min"]), std::stof(node.args["max"]));
121 | 			}
122 | 
123 | 			if(node.type == ImGuiEnum::INPUTTEXT) {
124 | 				ImGui::InputText(node.args["label"].c_str(), (char*)dynamicBinds.at(node.args["dynamic"]).ptr, dynamicBinds.at(node.args["dynamic"]).size, node.flags);
125 | 			}
126 | 
127 | 			if(node.type == ImGuiEnum::TREE) {
128 | 				renderTree(node, handler);
129 | 			}
130 | 
131 | 			if(node.type == ImGuiEnum::SEPARATOR) {
132 | 				ImGui::Separator();
133 | 			}
134 | 
135 | 			if(node.type == ImGuiEnum::SAMELINE) {
136 | 				sameline = 1;
137 | 			}
138 | 		}
139 | 
140 | 		void onNodeEnd(XMLNode& node, XMLEventHandler& handler, bool inPopup=false) {
141 | 			if(node.type == ImGuiEnum::BEGIN) {
142 | 				ImGui::End();
143 | 			}
144 | 			if(node.type == ImGuiEnum::POPUPCONTEXTWINDOW) {
145 | 				popup = false;
146 | 			}
147 | 			if(node.type == ImGuiEnum::SAMELINE) {
148 | 				sameline = false;
149 | 			}
150 | 			if(node.type == ImGuiEnum::COLUMN) {
151 | 				ImGui::NextColumn();
152 | 			}
153 | 			if(node.type == ImGuiEnum::GROUP) {
154 | 				ImGui::EndGroup();
155 | 			}
156 | 			handler.onNodeEnd(node);
157 | 		}
158 | 
159 | 		void traverse(XMLNode& root, XMLEventHandler& handler, bool inPopup=false) {
160 | 			onNodeBegin(root, handler, inPopup);
161 | 			for(auto child : root.children) {
162 | 				traverse(*child, handler, inPopup);
163 | 			}
164 | 			onNodeEnd(root, handler, inPopup);
165 | 		}
166 | 	public:
167 | 		XMLRenderer(/* args */);
168 | 		~XMLRenderer();
169 | 
170 | 		void render(XMLTree& tree, XMLEventHandler& handler) {
171 | 			XMLNode root = tree.getRoot();
172 | 			traverse(root, handler);
173 | 		}
174 | 
175 | 		void addDynamicBind(const std::string& name, const XMLDynamicBind& bind) {
176 | 			dynamicBinds.insert({name, bind});
177 | 		}
178 | 	};
179 | 	
180 | 	XMLRenderer::XMLRenderer(/* args */)
181 | 	{
182 | 	}
183 | 	
184 | 	XMLRenderer::~XMLRenderer()
185 | 	{
186 | 	}
187 | 	
188 | }
189 | 
190 | #endif /* XMLRENDERER_H */
191 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <a name="readme-top"></a>
  2 | 
  3 | <!-- PROJECT SHIELDS
  4 | [![Contributors][contributors-shield]][contributors-url]
  5 | [![Forks][forks-shield]][forks-url]
  6 | [![Stargazers][stars-shield]][stars-url]
  7 | [![Issues][issues-shield]][issues-url]
  8 | [![MIT License][license-shield]][license-url]
  9 | [![LinkedIn][linkedin-shield]][linkedin-url]
 10 |  -->
 11 | 
 12 | 
 13 | <!-- PROJECT LOGO -->
 14 | <br />
 15 | <div align="center">
 16 |   <a href="#">
 17 |     <img src="images/logo.png" alt="Logo" width="80" height="80">
 18 |   </a>
 19 | 
 20 |   <h3 align="center">Dear ImXML</h3>
 21 | 
 22 |   <p align="center">
 23 | 	A lightweight XML to ImGui library
 24 |     <br />
 25 |     <!--<a href="https://github.com/othneildrew/Best-README-Template"><strong>Explore the docs »</strong></a>
 26 |     <br />
 27 |     <br />
 28 |     <a href="https://github.com/othneildrew/Best-README-Template">View Demo</a>
 29 |     ·
 30 |     <a href="https://github.com/othneildrew/Best-README-Template/issues">Report Bug</a>
 31 |     ·
 32 |     <a href="https://github.com/othneildrew/Best-README-Template/issues">Request Feature</a>-->
 33 |   </p>
 34 | </div>
 35 | 
 36 | 
 37 | 
 38 | <!-- TABLE OF CONTENTS 
 39 | <details>
 40 |   <summary>Table of Contents</summary>
 41 |   <ol>
 42 |     <li>
 43 |       <a href="#about-the-project">About The Project</a>
 44 |       <ul>
 45 |         <li><a href="#built-with">Built With</a></li>
 46 |       </ul>
 47 |     </li>
 48 |     <li>
 49 |       <a href="#getting-started">Getting Started</a>
 50 |       <ul>
 51 |         <li><a href="#prerequisites">Prerequisites</a></li>
 52 |         <li><a href="#installation">Installation</a></li>
 53 |       </ul>
 54 |     </li>
 55 |     <li><a href="#usage">Usage</a></li>
 56 |     <li><a href="#roadmap">Roadmap</a></li>
 57 |     <li><a href="#contributing">Contributing</a></li>
 58 |     <li><a href="#license">License</a></li>
 59 |     <li><a href="#contact">Contact</a></li>
 60 |     <li><a href="#acknowledgments">Acknowledgments</a></li>
 61 |   </ol>
 62 | </details>
 63 | -->
 64 | 
 65 | 
 66 | <!-- ABOUT THE PROJECT -->
 67 | ## About The Project
 68 | 
 69 | Dear ImXML allows you to writer ImGui interfaces in an XML format and render / interact with them at runtime.
 70 | 
 71 | For example this XML file
 72 | ```XML
 73 | <?xml version="1.0" encoding="UTF-8"?>
 74 | 
 75 | <begin name="Title window" flags="ImGuiWindowFlags_MenuBar|ImGuiWindowFlags_NoCollapse">
 76 | 	<columns count="2"/>
 77 | 	<menubar>
 78 | 		<menu label="File">
 79 | 			<menuitem label="New..."/>
 80 | 			<menu label="Open...">
 81 | 				<menuitem label="File1.txt" />
 82 | 			</menu>
 83 | 		</menu>
 84 | 		<menu label="Edit">
 85 | 			<menuitem label="Foo"/>
 86 | 			<menuitem label="Bar"/>
 87 | 		</menu>
 88 | 	</menubar>
 89 | 	<column>
 90 | 		<sameline>
 91 | 			<text label="Text"/>
 92 | 			<button id="btn0" label="Hello!"/>
 93 | 		</sameline>
 94 | 		<text label="new line"/>
 95 | 		<sliderfloat label="float" dynamic="float0" min="0" max="1" />
 96 | 		<inputtext label="string" dynamic="str0"/>
 97 | 	</column>
 98 | 	<column>
 99 | 		<tree>
100 | 			<treenode label="treeroot">
101 | 				<treenode label="tree0" />
102 | 				<treenode label="tree1">
103 | 					<treenode label="tree2" />
104 | 				</treenode>
105 | 			</treenode>
106 | 		</tree>
107 | 		<group>
108 | 			<colorpicker3 dynamic="color0" />
109 | 		</group>
110 | 		<group>
111 | 			<PopupContextWindow>
112 | 				<text label="context popup"/>
113 | 			</PopupContextWindow>
114 | 			<text label="right click to open popup"/>
115 | 		</group>
116 | 	</column>
117 | </begin>
118 | 
119 | ```
120 | 
121 | Turns into this window
122 | ![Demo gif](images/demo.gif)
123 | 
124 | Note that the project is at an early phase, not all ImGui elements are supported but it's rapidly being expanded.
125 | <!--[![Product Name Screen Shot][product-screenshot]](https://example.com)-->
126 | 
127 | 
128 | 
129 | 
130 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
131 | 
132 | 
133 | 
134 | ### Built With
135 | ![CMake](https://img.shields.io/badge/CMake-%23008FBA.svg?style=for-the-badge&logo=cmake&logoColor=white) ![C++](https://img.shields.io/badge/c++-%2300599C.svg?style=for-the-badge&logo=c%2B%2B&logoColor=white) 
136 | 
137 | 
138 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
139 | 
140 | 
141 | 
142 | <!-- GETTING STARTED -->
143 | ## Getting Started
144 | 
145 | ### Prerequisites
146 | 
147 | You will need CMake
148 | 
149 | ### Installation
150 | 
151 | Clone the repo or include it as submodule, build target `DearImXML` and link the library to you project.
152 | You can also add the header file directly to your project and include them in the compilation process.
153 | 
154 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
155 | 
156 | <!-- USAGE EXAMPLES
157 | ## Usage
158 | 
159 | Use this space to show useful examples of how a project can be used. Additional screenshots, code examples and demos work well in this space. You may also link to more resources.
160 | 
161 | _For more examples, please refer to the [Documentation](https://example.com)_
162 | 
163 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
164 |  -->
165 | 
166 | 
167 | <!-- ROADMAP 
168 | ## Roadmap
169 | 
170 | - [x] Add Changelog
171 | - [x] Add back to top links
172 | - [ ] Add Additional Templates w/ Examples
173 | - [ ] Add "components" document to easily copy & paste sections of the readme
174 | - [ ] Multi-language Support
175 |     - [ ] Chinese
176 |     - [ ] Spanish
177 | 
178 | See the [open issues](https://github.com/othneildrew/Best-README-Template/issues) for a full list of proposed features (and known issues).
179 | 
180 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
181 | 
182 | -->
183 | <!-- CONTRIBUTING -->
184 | ## Contributing
185 | 
186 | If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement".
187 | Don't forget to give the project a star! Thanks again!
188 | 
189 | 1. Fork the Project
190 | 2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
191 | 3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
192 | 4. Push to the Branch (`git push origin feature/AmazingFeature`)
193 | 5. Open a Pull Request
194 | 
195 | 
196 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
197 | 
198 | 
199 | 
200 | <!-- LICENSE 
201 | ## License
202 | 
203 | Distributed under the MIT License. See `LICENSE.txt` for more information.
204 | 
205 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
206 | -->
207 | 
208 | 
209 | <!-- CONTACT -->
210 | ## Contact
211 | 
212 | Feel free to tag me in an issue or send me an email at thomas (dot) ibanez33 (@) gmail (dot) com
213 | 
214 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
215 | 
216 | 
217 | 
218 | <!-- ACKNOWLEDGMENTS -->
219 | ## Acknowledgments
220 | 
221 | * [DearImGui](https://github.com/ocornut/imgui/)
222 | * [Choose an Open Source License](https://choosealicense.com)
223 | * [Markdown Badges](https://ileriayo.github.io/markdown-badges/)
224 | * [Awesome Readme](https://github.com/matiassingers/awesome-readme)
225 | 
226 | <p align="right">(<a href="#readme-top">back to top</a>)</p>
227 | 
228 | 
229 | 
230 | <!-- MARKDOWN LINKS & IMAGES -->
231 | <!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
232 | 
233 | [contributors-shield]: https://img.shields.io/github/contributors/othneildrew/Best-README-Template.svg?style=for-the-badge
234 | [contributors-url]: https://github.com/othneildrew/Best-README-Template/graphs/contributors
235 | [forks-shield]: https://img.shields.io/github/forks/othneildrew/Best-README-Template.svg?style=for-the-badge
236 | [forks-url]: https://github.com/othneildrew/Best-README-Template/network/members
237 | [stars-shield]: https://img.shields.io/github/stars/othneildrew/Best-README-Template.svg?style=for-the-badge
238 | [stars-url]: https://github.com/othneildrew/Best-README-Template/stargazers
239 | [issues-shield]: https://img.shields.io/github/issues/othneildrew/Best-README-Template.svg?style=for-the-badge
240 | [issues-url]: https://github.com/othneildrew/Best-README-Template/issues
241 | [license-shield]: https://img.shields.io/github/license/othneildrew/Best-README-Template.svg?style=for-the-badge
242 | [license-url]: https://github.com/othneildrew/Best-README-Template/blob/master/LICENSE.txt
243 | [linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
244 | [linkedin-url]: https://linkedin.com/in/othneildrew
245 | 


--------------------------------------------------------------------------------
/includes/ImGUI/imconfig.h:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------------
  2 | // DEAR IMGUI COMPILE-TIME OPTIONS
  3 | // Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
  4 | // You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
  5 | //-----------------------------------------------------------------------------
  6 | // A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
  7 | // B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
  8 | //-----------------------------------------------------------------------------
  9 | // You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
 10 | // files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
 11 | // Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
 12 | // Call IMGUI_CHECKVERSION() from your .cpp file to verify that the data structures your files are using are matching the ones imgui.cpp is using.
 13 | //-----------------------------------------------------------------------------
 14 | 
 15 | #pragma once
 16 | 
 17 | //---- Define assertion handler. Defaults to calling assert().
 18 | // If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
 19 | //#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
 20 | //#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
 21 | 
 22 | //---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
 23 | // Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
 24 | // DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
 25 | // for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
 26 | //#define IMGUI_API __declspec( dllexport )
 27 | //#define IMGUI_API __declspec( dllimport )
 28 | 
 29 | //---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to clean your code of obsolete function/names.
 30 | //#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
 31 | //#define IMGUI_DISABLE_OBSOLETE_KEYIO                      // 1.87: disable legacy io.KeyMap[]+io.KeysDown[] in favor io.AddKeyEvent(). This will be folded into IMGUI_DISABLE_OBSOLETE_FUNCTIONS in a few versions.
 32 | 
 33 | //---- Disable all of Dear ImGui or don't implement standard windows/tools.
 34 | // It is very strongly recommended to NOT disable the demo windows and debug tool during development. They are extremely useful in day to day work. Please read comments in imgui_demo.cpp.
 35 | //#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
 36 | //#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty.
 37 | //#define IMGUI_DISABLE_DEBUG_TOOLS                         // Disable metrics/debugger and other debug tools: ShowMetricsWindow(), ShowDebugLogWindow() and ShowIDStackToolWindow() will be empty.
 38 | 
 39 | //---- Don't implement some functions to reduce linkage requirements.
 40 | //#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
 41 | //#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
 42 | //#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
 43 | //#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, IME).
 44 | //#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
 45 | //#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
 46 | //#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
 47 | //#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
 48 | //#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
 49 | //#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
 50 | //#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
 51 | 
 52 | //---- Include imgui_user.h at the end of imgui.h as a convenience
 53 | //#define IMGUI_INCLUDE_IMGUI_USER_H
 54 | 
 55 | //---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
 56 | //#define IMGUI_USE_BGRA_PACKED_COLOR
 57 | 
 58 | //---- Use 32-bit for ImWchar (default is 16-bit) to support unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
 59 | //#define IMGUI_USE_WCHAR32
 60 | 
 61 | //---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
 62 | // By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
 63 | //#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
 64 | //#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
 65 | //#define IMGUI_STB_SPRINTF_FILENAME    "my_folder/stb_sprintf.h"    // only used if IMGUI_USE_STB_SPRINTF is defined.
 66 | //#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
 67 | //#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
 68 | //#define IMGUI_DISABLE_STB_SPRINTF_IMPLEMENTATION                   // only disabled if IMGUI_USE_STB_SPRINTF is defined.
 69 | 
 70 | //---- Use stb_sprintf.h for a faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
 71 | // Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by stb_sprintf.h.
 72 | //#define IMGUI_USE_STB_SPRINTF
 73 | 
 74 | //---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
 75 | // Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
 76 | // On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
 77 | //#define IMGUI_ENABLE_FREETYPE
 78 | 
 79 | //---- Use FreeType+lunasvg library to render OpenType SVG fonts (SVGinOT)
 80 | // Requires lunasvg headers to be available in the include path + program to be linked with the lunasvg library (not provided).
 81 | // Only works in combination with IMGUI_ENABLE_FREETYPE.
 82 | // (implementation is based on Freetype's rsvg-port.c which is licensed under CeCILL-C Free Software License Agreement)
 83 | //#define IMGUI_ENABLE_FREETYPE_LUNASVG
 84 | 
 85 | //---- Use stb_truetype to build and rasterize the font atlas (default)
 86 | // The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
 87 | //#define IMGUI_ENABLE_STB_TRUETYPE
 88 | 
 89 | //---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
 90 | // This will be inlined as part of ImVec2 and ImVec4 class declarations.
 91 | /*
 92 | #define IM_VEC2_CLASS_EXTRA                                                     \
 93 |         constexpr ImVec2(const MyVec2& f) : x(f.x), y(f.y) {}                   \
 94 |         operator MyVec2() const { return MyVec2(x,y); }
 95 | 
 96 | #define IM_VEC4_CLASS_EXTRA                                                     \
 97 |         constexpr ImVec4(const MyVec4& f) : x(f.x), y(f.y), z(f.z), w(f.w) {}   \
 98 |         operator MyVec4() const { return MyVec4(x,y,z,w); }
 99 | */
100 | //---- ...Or use Dear ImGui's own very basic math operators.
101 | //#define IMGUI_DEFINE_MATH_OPERATORS
102 | 
103 | //---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
104 | // Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
105 | // Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
106 | // Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
107 | //#define ImDrawIdx unsigned int
108 | 
109 | //---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
110 | //struct ImDrawList;
111 | //struct ImDrawCmd;
112 | //typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
113 | //#define ImDrawCallback MyImDrawCallback
114 | 
115 | //---- Debug Tools: Macro to break in Debugger (we provide a default implementation of this in the codebase)
116 | // (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
117 | //#define IM_DEBUG_BREAK  IM_ASSERT(0)
118 | //#define IM_DEBUG_BREAK  __debugbreak()
119 | 
120 | //---- Debug Tools: Enable slower asserts
121 | //#define IMGUI_DEBUG_PARANOID
122 | 
123 | //---- Tip: You can add extra functions within the ImGui:: namespace from anywhere (e.g. your own sources/header files)
124 | /*
125 | namespace ImGui
126 | {
127 |     void MyFunction(const char* name, MyMatrix44* mtx);
128 | }
129 | */
130 | 


--------------------------------------------------------------------------------
/includes/KHR/khrplatform.h:
--------------------------------------------------------------------------------
  1 | #ifndef __khrplatform_h_
  2 | #define __khrplatform_h_
  3 | 
  4 | /*
  5 | ** Copyright (c) 2008-2018 The Khronos Group Inc.
  6 | **
  7 | ** Permission is hereby granted, free of charge, to any person obtaining a
  8 | ** copy of this software and/or associated documentation files (the
  9 | ** "Materials"), to deal in the Materials without restriction, including
 10 | ** without limitation the rights to use, copy, modify, merge, publish,
 11 | ** distribute, sublicense, and/or sell copies of the Materials, and to
 12 | ** permit persons to whom the Materials are furnished to do so, subject to
 13 | ** the following conditions:
 14 | **
 15 | ** The above copyright notice and this permission notice shall be included
 16 | ** in all copies or substantial portions of the Materials.
 17 | **
 18 | ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 19 | ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 20 | ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 21 | ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 22 | ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 23 | ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 24 | ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 25 | */
 26 | 
 27 | /* Khronos platform-specific types and definitions.
 28 |  *
 29 |  * The master copy of khrplatform.h is maintained in the Khronos EGL
 30 |  * Registry repository at https://github.com/KhronosGroup/EGL-Registry
 31 |  * The last semantic modification to khrplatform.h was at commit ID:
 32 |  *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
 33 |  *
 34 |  * Adopters may modify this file to suit their platform. Adopters are
 35 |  * encouraged to submit platform specific modifications to the Khronos
 36 |  * group so that they can be included in future versions of this file.
 37 |  * Please submit changes by filing pull requests or issues on
 38 |  * the EGL Registry repository linked above.
 39 |  *
 40 |  *
 41 |  * See the Implementer's Guidelines for information about where this file
 42 |  * should be located on your system and for more details of its use:
 43 |  *    http://www.khronos.org/registry/implementers_guide.pdf
 44 |  *
 45 |  * This file should be included as
 46 |  *        #include <KHR/khrplatform.h>
 47 |  * by Khronos client API header files that use its types and defines.
 48 |  *
 49 |  * The types in khrplatform.h should only be used to define API-specific types.
 50 |  *
 51 |  * Types defined in khrplatform.h:
 52 |  *    khronos_int8_t              signed   8  bit
 53 |  *    khronos_uint8_t             unsigned 8  bit
 54 |  *    khronos_int16_t             signed   16 bit
 55 |  *    khronos_uint16_t            unsigned 16 bit
 56 |  *    khronos_int32_t             signed   32 bit
 57 |  *    khronos_uint32_t            unsigned 32 bit
 58 |  *    khronos_int64_t             signed   64 bit
 59 |  *    khronos_uint64_t            unsigned 64 bit
 60 |  *    khronos_intptr_t            signed   same number of bits as a pointer
 61 |  *    khronos_uintptr_t           unsigned same number of bits as a pointer
 62 |  *    khronos_ssize_t             signed   size
 63 |  *    khronos_usize_t             unsigned size
 64 |  *    khronos_float_t             signed   32 bit floating point
 65 |  *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
 66 |  *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
 67 |  *                                         nanoseconds
 68 |  *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
 69 |  *    khronos_boolean_enum_t      enumerated boolean type. This should
 70 |  *      only be used as a base type when a client API's boolean type is
 71 |  *      an enum. Client APIs which use an integer or other type for
 72 |  *      booleans cannot use this as the base type for their boolean.
 73 |  *
 74 |  * Tokens defined in khrplatform.h:
 75 |  *
 76 |  *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
 77 |  *
 78 |  *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
 79 |  *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
 80 |  *
 81 |  * Calling convention macros defined in this file:
 82 |  *    KHRONOS_APICALL
 83 |  *    KHRONOS_APIENTRY
 84 |  *    KHRONOS_APIATTRIBUTES
 85 |  *
 86 |  * These may be used in function prototypes as:
 87 |  *
 88 |  *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
 89 |  *                                  int arg1,
 90 |  *                                  int arg2) KHRONOS_APIATTRIBUTES;
 91 |  */
 92 | 
 93 | #if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
 94 | #   define KHRONOS_STATIC 1
 95 | #endif
 96 | 
 97 | /*-------------------------------------------------------------------------
 98 |  * Definition of KHRONOS_APICALL
 99 |  *-------------------------------------------------------------------------
100 |  * This precedes the return type of the function in the function prototype.
101 |  */
102 | #if defined(KHRONOS_STATIC)
103 |     /* If the preprocessor constant KHRONOS_STATIC is defined, make the
104 |      * header compatible with static linking. */
105 | #   define KHRONOS_APICALL
106 | #elif defined(_WIN32)
107 | #   define KHRONOS_APICALL __declspec(dllimport)
108 | #elif defined (__SYMBIAN32__)
109 | #   define KHRONOS_APICALL IMPORT_C
110 | #elif defined(__ANDROID__)
111 | #   define KHRONOS_APICALL __attribute__((visibility("default")))
112 | #else
113 | #   define KHRONOS_APICALL
114 | #endif
115 | 
116 | /*-------------------------------------------------------------------------
117 |  * Definition of KHRONOS_APIENTRY
118 |  *-------------------------------------------------------------------------
119 |  * This follows the return type of the function  and precedes the function
120 |  * name in the function prototype.
121 |  */
122 | #if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
123 |     /* Win32 but not WinCE */
124 | #   define KHRONOS_APIENTRY __stdcall
125 | #else
126 | #   define KHRONOS_APIENTRY
127 | #endif
128 | 
129 | /*-------------------------------------------------------------------------
130 |  * Definition of KHRONOS_APIATTRIBUTES
131 |  *-------------------------------------------------------------------------
132 |  * This follows the closing parenthesis of the function prototype arguments.
133 |  */
134 | #if defined (__ARMCC_2__)
135 | #define KHRONOS_APIATTRIBUTES __softfp
136 | #else
137 | #define KHRONOS_APIATTRIBUTES
138 | #endif
139 | 
140 | /*-------------------------------------------------------------------------
141 |  * basic type definitions
142 |  *-----------------------------------------------------------------------*/
143 | #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
144 | 
145 | 
146 | /*
147 |  * Using <stdint.h>
148 |  */
149 | #include <stdint.h>
150 | typedef int32_t                 khronos_int32_t;
151 | typedef uint32_t                khronos_uint32_t;
152 | typedef int64_t                 khronos_int64_t;
153 | typedef uint64_t                khronos_uint64_t;
154 | #define KHRONOS_SUPPORT_INT64   1
155 | #define KHRONOS_SUPPORT_FLOAT   1
156 | 
157 | #elif defined(__VMS ) || defined(__sgi)
158 | 
159 | /*
160 |  * Using <inttypes.h>
161 |  */
162 | #include <inttypes.h>
163 | typedef int32_t                 khronos_int32_t;
164 | typedef uint32_t                khronos_uint32_t;
165 | typedef int64_t                 khronos_int64_t;
166 | typedef uint64_t                khronos_uint64_t;
167 | #define KHRONOS_SUPPORT_INT64   1
168 | #define KHRONOS_SUPPORT_FLOAT   1
169 | 
170 | #elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
171 | 
172 | /*
173 |  * Win32
174 |  */
175 | typedef __int32                 khronos_int32_t;
176 | typedef unsigned __int32        khronos_uint32_t;
177 | typedef __int64                 khronos_int64_t;
178 | typedef unsigned __int64        khronos_uint64_t;
179 | #define KHRONOS_SUPPORT_INT64   1
180 | #define KHRONOS_SUPPORT_FLOAT   1
181 | 
182 | #elif defined(__sun__) || defined(__digital__)
183 | 
184 | /*
185 |  * Sun or Digital
186 |  */
187 | typedef int                     khronos_int32_t;
188 | typedef unsigned int            khronos_uint32_t;
189 | #if defined(__arch64__) || defined(_LP64)
190 | typedef long int                khronos_int64_t;
191 | typedef unsigned long int       khronos_uint64_t;
192 | #else
193 | typedef long long int           khronos_int64_t;
194 | typedef unsigned long long int  khronos_uint64_t;
195 | #endif /* __arch64__ */
196 | #define KHRONOS_SUPPORT_INT64   1
197 | #define KHRONOS_SUPPORT_FLOAT   1
198 | 
199 | #elif 0
200 | 
201 | /*
202 |  * Hypothetical platform with no float or int64 support
203 |  */
204 | typedef int                     khronos_int32_t;
205 | typedef unsigned int            khronos_uint32_t;
206 | #define KHRONOS_SUPPORT_INT64   0
207 | #define KHRONOS_SUPPORT_FLOAT   0
208 | 
209 | #else
210 | 
211 | /*
212 |  * Generic fallback
213 |  */
214 | #include <stdint.h>
215 | typedef int32_t                 khronos_int32_t;
216 | typedef uint32_t                khronos_uint32_t;
217 | typedef int64_t                 khronos_int64_t;
218 | typedef uint64_t                khronos_uint64_t;
219 | #define KHRONOS_SUPPORT_INT64   1
220 | #define KHRONOS_SUPPORT_FLOAT   1
221 | 
222 | #endif
223 | 
224 | 
225 | /*
226 |  * Types that are (so far) the same on all platforms
227 |  */
228 | typedef signed   char          khronos_int8_t;
229 | typedef unsigned char          khronos_uint8_t;
230 | typedef signed   short int     khronos_int16_t;
231 | typedef unsigned short int     khronos_uint16_t;
232 | 
233 | /*
234 |  * Types that differ between LLP64 and LP64 architectures - in LLP64,
235 |  * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
236 |  * to be the only LLP64 architecture in current use.
237 |  */
238 | #ifdef _WIN64
239 | typedef signed   long long int khronos_intptr_t;
240 | typedef unsigned long long int khronos_uintptr_t;
241 | typedef signed   long long int khronos_ssize_t;
242 | typedef unsigned long long int khronos_usize_t;
243 | #else
244 | typedef signed   long  int     khronos_intptr_t;
245 | typedef unsigned long  int     khronos_uintptr_t;
246 | typedef signed   long  int     khronos_ssize_t;
247 | typedef unsigned long  int     khronos_usize_t;
248 | #endif
249 | 
250 | #if KHRONOS_SUPPORT_FLOAT
251 | /*
252 |  * Float type
253 |  */
254 | typedef          float         khronos_float_t;
255 | #endif
256 | 
257 | #if KHRONOS_SUPPORT_INT64
258 | /* Time types
259 |  *
260 |  * These types can be used to represent a time interval in nanoseconds or
261 |  * an absolute Unadjusted System Time.  Unadjusted System Time is the number
262 |  * of nanoseconds since some arbitrary system event (e.g. since the last
263 |  * time the system booted).  The Unadjusted System Time is an unsigned
264 |  * 64 bit value that wraps back to 0 every 584 years.  Time intervals
265 |  * may be either signed or unsigned.
266 |  */
267 | typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
268 | typedef khronos_int64_t        khronos_stime_nanoseconds_t;
269 | #endif
270 | 
271 | /*
272 |  * Dummy value used to pad enum types to 32 bits.
273 |  */
274 | #ifndef KHRONOS_MAX_ENUM
275 | #define KHRONOS_MAX_ENUM 0x7FFFFFFF
276 | #endif
277 | 
278 | /*
279 |  * Enumerated boolean type
280 |  *
281 |  * Values other than zero should be considered to be true.  Therefore
282 |  * comparisons should not be made against KHRONOS_TRUE.
283 |  */
284 | typedef enum {
285 |     KHRONOS_FALSE = 0,
286 |     KHRONOS_TRUE  = 1,
287 |     KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
288 | } khronos_boolean_enum_t;
289 | 
290 | #endif /* __khrplatform_h_ */
291 | 


--------------------------------------------------------------------------------
/DearImXML/src/XMLReader.h:
--------------------------------------------------------------------------------
  1 | #ifndef XMLREADER_H
  2 | #define XMLREADER_H
  3 | 
  4 | #include <string>
  5 | #include <XMLTree.h>
  6 | #include <ImGuiEnum.h>
  7 | #include <fstream>
  8 | #include <iostream>
  9 | #include <regex>
 10 | #include <stack>
 11 | #include <unordered_map>
 12 | #include <ImGUI/imgui.h>
 13 | #include <algorithm>
 14 | 
 15 | namespace ImXML {
 16 | 	class XMLReader
 17 | 	{
 18 | 	private:
 19 | 		/* data */
 20 | 		static constexpr const char* ws = " \t\n\r\f\v";
 21 | 		static const std::unordered_map<std::string, ImGuiEnum> tagnames;
 22 | 		static const std::unordered_map<std::string, int> flagnames;
 23 | 
 24 | 		// trim from end of string (right)
 25 | 		inline std::string& rtrim(std::string& s, const char* t = ws) {
 26 | 			s.erase(s.find_last_not_of(t) + 1);
 27 | 			return s;
 28 | 		}
 29 | 
 30 | 		// trim from beginning of string (left)
 31 | 		inline std::string& ltrim(std::string& s, const char* t = ws) {
 32 | 			s.erase(0, s.find_first_not_of(t));
 33 | 			return s;
 34 | 		}
 35 | 
 36 | 		// trim from both ends of string (right then left)
 37 | 		inline std::string& trim(std::string& s, const char* t = ws) {
 38 | 			return ltrim(rtrim(s, t), t);
 39 | 		}
 40 | 
 41 | 		std::vector<std::string> tokenize(const std::string& line, const std::string& delimiters) {
 42 | 			std::vector<std::string> tokens;
 43 | 			int last = 0;
 44 | 			int i = 0;
 45 | 			for(char c : line) {
 46 | 				bool match = false;
 47 | 				for(char d : delimiters) {
 48 | 					if(c == d) {
 49 | 						match = true;
 50 | 						break;
 51 | 					}
 52 | 				}
 53 | 				if(match) {
 54 | 					tokens.push_back(line.substr(last, i-last));
 55 | 					last = i+1;
 56 | 				}
 57 | 				i++;
 58 | 			}
 59 | 			tokens.push_back(line.substr(last, i-last));
 60 | 			return tokens;
 61 | 		}
 62 | 
 63 | 		int parseFlags(std::string& flagstr) {
 64 | 			auto flags = tokenize(flagstr, "|,");
 65 | 			int parsed = 0;
 66 | 			for(auto flag : flags) {
 67 | 				parsed |= flagnames.at(trim(flag));
 68 | 			}
 69 | 			return parsed;
 70 | 		}
 71 | 
 72 | 		XMLNode* stringToNode(std::string& str) {
 73 | 			std::regex tagname = std::regex(R"(<\/?\w+)");
 74 | 			std::smatch m;
 75 | 			std::regex_search(str, m, tagname);
 76 | 			auto prefix = m.str(0);
 77 | 			auto name = prefix.substr(1, prefix.length()-1);
 78 | 			XMLNode* node = new XMLNode;
 79 | 			std::transform(name.begin(), name.end(), name.begin(), ::tolower);
 80 | 			if(tagnames.find(name) == tagnames.end()) {
 81 | 				throw std::runtime_error("Unknown tag " + name);
 82 | 			}
 83 | 			node->type = tagnames.at(name);
 84 | 
 85 | 			std::regex arguments = std::regex(R"(\w+=\"[^"]+\")");
 86 | 			std::string::const_iterator searchStart(str.cbegin());
 87 | 
 88 | 			while(std::regex_search(searchStart, str.cend(), m, arguments)) {
 89 | 				for(auto x : m) {
 90 | 					auto argstr = x.str();
 91 | 					auto argtoken = tokenize(argstr, "=");
 92 | 					node->args.insert({argtoken[0], argtoken[1].substr(1, argtoken[1].length()-2)});
 93 | 					//Special case, flags must be converted
 94 | 					if(argtoken[0] == "flags") {
 95 | 						node->flags = parseFlags(node->args["flags"]);
 96 | 					}
 97 | 				}
 98 | 				searchStart = m.suffix().first;
 99 | 			}
100 | 			return node;
101 | 		}
102 | 
103 | 		XMLTree traverse(std::vector<std::string>& tags) {
104 | 			std::stack<XMLNode*> parents;
105 | 			XMLNode* lastparent = nullptr;
106 | 			for(auto tagstr : tags) {
107 | 				if(tagstr.at(1) == '/') {
108 | 					lastparent = parents.top();
109 | 					parents.pop();
110 | 				} else {
111 | 					XMLNode* node = stringToNode(tagstr);
112 | 					if(parents.size() > 0) {
113 | 						parents.top()->children.push_back(node);
114 | 					}
115 | 					//not a inline tag
116 | 					if(tagstr.at(tagstr.length()-2) != '/') {
117 | 						parents.push(node);
118 | 					}
119 | 				}
120 | 			}
121 | 			return XMLTree(*lastparent);
122 | 		}
123 | 	public:
124 | 		XMLReader();
125 | 		~XMLReader();
126 | 
127 | 		XMLTree read(std::string filename);
128 | 	};
129 | 	
130 | 	XMLReader::XMLReader()
131 | 	{
132 | 	}
133 | 	
134 | 	XMLReader::~XMLReader()
135 | 	{
136 | 	}
137 | 
138 | 	XMLTree XMLReader::read(std::string filename) {
139 | 		std::ifstream file(filename);
140 | 		std::string str;
141 | 		std::vector<std::string> taglines;
142 | 		while (std::getline(file, str))
143 | 		{
144 | 			std::string trimmed = trim(str);
145 | 			if(trimmed.length() <= 0) {
146 | 				continue;
147 | 			}
148 | 			if(trimmed.at(0) != '<') {
149 | 				throw std::runtime_error("Invalid XML line");
150 | 			}
151 | 
152 | 			std::regex tagregex = std::regex(R"(^<\s*[^\?][ -~]+\/?>)");
153 | 			std::smatch m;
154 | 			if(std::regex_search(trimmed, m, tagregex)) {
155 | 				taglines.push_back(m.str(0));
156 | 			}
157 | 
158 | 		}
159 | 
160 | 		return traverse(taglines);
161 | 	}
162 | 
163 | 	const std::unordered_map<std::string, ImGuiEnum> XMLReader::tagnames = {
164 | 		{ "begin", ImGuiEnum::BEGIN },
165 | 		{ "button" , ImGuiEnum::BUTTON },
166 | 		{ "placeholder", ImGuiEnum::PLACEHOLDER },
167 | 		{ "text", ImGuiEnum::TEXT },
168 | 		{ "sameline", ImGuiEnum::SAMELINE },
169 | 		{ "menubar", ImGuiEnum::MENUBAR },
170 | 		{ "menu", ImGuiEnum::MENU },
171 | 		{ "menuitem", ImGuiEnum::MENUITEM },
172 | 		{ "sliderfloat", ImGuiEnum::SLIDERFLOAT },
173 | 		{ "inputtext", ImGuiEnum::INPUTTEXT },
174 | 		{ "treenode", ImGuiEnum::TREENODE },
175 | 		{ "tree", ImGuiEnum::TREE },
176 | 		{ "columns", ImGuiEnum::COLUMNS },
177 | 		{ "column", ImGuiEnum::COLUMN },
178 | 		{ "group", ImGuiEnum::GROUP },
179 | 		{ "colorpicker3", ImGuiEnum::COLORPICKER3 },
180 | 		{ "colorpicker4", ImGuiEnum::COLORPICKER4 },
181 | 		{ "coloredit3", ImGuiEnum::COLOREDIT3 },
182 | 		{ "coloredit4", ImGuiEnum::COLOREDIT4 },
183 | 		{ "popupcontextwindow", ImGuiEnum::POPUPCONTEXTWINDOW },
184 | 		{ "separator", ImGuiEnum::SEPARATOR },
185 | 
186 | 	};
187 | 
188 | 	const std::unordered_map<std::string, int> XMLReader::flagnames = {
189 | 		//Window flags
190 | 		{ "ImGuiWindowFlags_None", ImGuiWindowFlags_None },
191 | 		{ "ImGuiWindowFlags_NoTitleBar", ImGuiWindowFlags_NoTitleBar },
192 | 		{ "ImGuiWindowFlags_NoResize", ImGuiWindowFlags_NoResize },
193 | 		{ "ImGuiWindowFlags_NoMove", ImGuiWindowFlags_NoMove },
194 | 		{ "ImGuiWindowFlags_NoScrollbar", ImGuiWindowFlags_NoScrollbar },
195 | 		{ "ImGuiWindowFlags_NoScrollWithMouse", ImGuiWindowFlags_NoScrollWithMouse },
196 | 		{ "ImGuiWindowFlags_NoCollapse", ImGuiWindowFlags_NoCollapse },
197 | 		{ "ImGuiWindowFlags_AlwaysAutoResize", ImGuiWindowFlags_AlwaysAutoResize },
198 | 		{ "ImGuiWindowFlags_NoBackground", ImGuiWindowFlags_NoBackground },
199 | 		{ "ImGuiWindowFlags_NoSavedSettings", ImGuiWindowFlags_NoSavedSettings },
200 | 		{ "ImGuiWindowFlags_NoMouseInputs", ImGuiWindowFlags_NoMouseInputs },
201 | 		{ "ImGuiWindowFlags_MenuBar", ImGuiWindowFlags_MenuBar },
202 | 		{ "ImGuiWindowFlags_HorizontalScrollbar", ImGuiWindowFlags_HorizontalScrollbar },
203 | 		{ "ImGuiWindowFlags_NoFocusOnAppearing", ImGuiWindowFlags_NoFocusOnAppearing },
204 | 		{ "ImGuiWindowFlags_NoBringToFrontOnFocus", ImGuiWindowFlags_NoBringToFrontOnFocus },
205 | 		{ "ImGuiWindowFlags_AlwaysVerticalScrollbar", ImGuiWindowFlags_AlwaysVerticalScrollbar },
206 | 		{ "ImGuiWindowFlags_AlwaysHorizontalScrollbar", ImGuiWindowFlags_AlwaysHorizontalScrollbar },
207 | 		{ "ImGuiWindowFlags_AlwaysUseWindowPadding", ImGuiWindowFlags_AlwaysUseWindowPadding },
208 | 		{ "ImGuiWindowFlags_NoNavInputs", ImGuiWindowFlags_NoNavInputs },
209 | 		{ "ImGuiWindowFlags_NoNavFocus", ImGuiWindowFlags_NoNavFocus },
210 | 		{ "ImGuiWindowFlags_UnsavedDocument", ImGuiWindowFlags_UnsavedDocument },
211 | 		{ "ImGuiWindowFlags_NoNav", ImGuiWindowFlags_NoNav },
212 | 		{ "ImGuiWindowFlags_NoDecoration", ImGuiWindowFlags_NoDecoration },
213 | 		{ "ImGuiWindowFlags_NoInputs", ImGuiWindowFlags_NoInputs },
214 | 		{ "ImGuiWindowFlags_NavFlattened", ImGuiWindowFlags_NavFlattened },
215 | 		{ "ImGuiWindowFlags_ChildWindow", ImGuiWindowFlags_ChildWindow },
216 | 		{ "ImGuiWindowFlags_Tooltip", ImGuiWindowFlags_Tooltip },
217 | 		{ "ImGuiWindowFlags_Popup", ImGuiWindowFlags_Popup },
218 | 		{ "ImGuiWindowFlags_Modal", ImGuiWindowFlags_Modal },
219 | 		{ "ImGuiWindowFlags_ChildMenu", ImGuiWindowFlags_ChildMenu },
220 | 
221 | 		//InputText flags
222 | 		{ "ImGuiInputTextFlags_None", ImGuiInputTextFlags_None },
223 | 		{ "ImGuiInputTextFlags_CharsDecimal", ImGuiInputTextFlags_CharsDecimal },
224 | 		{ "ImGuiInputTextFlags_CharsHexadecimal", ImGuiInputTextFlags_CharsHexadecimal },
225 | 		{ "ImGuiInputTextFlags_CharsUppercase", ImGuiInputTextFlags_CharsUppercase },
226 | 		{ "ImGuiInputTextFlags_CharsNoBlank", ImGuiInputTextFlags_CharsNoBlank },
227 | 		{ "ImGuiInputTextFlags_AutoSelectAll", ImGuiInputTextFlags_AutoSelectAll },
228 | 		{ "ImGuiInputTextFlags_EnterReturnsTrue", ImGuiInputTextFlags_EnterReturnsTrue },
229 | 		{ "ImGuiInputTextFlags_CallbackCompletion", ImGuiInputTextFlags_CallbackCompletion },
230 | 		{ "ImGuiInputTextFlags_CallbackHistory", ImGuiInputTextFlags_CallbackHistory },
231 | 		{ "ImGuiInputTextFlags_CallbackAlways", ImGuiInputTextFlags_CallbackAlways },
232 | 		{ "ImGuiInputTextFlags_CallbackCharFilter", ImGuiInputTextFlags_CallbackCharFilter },
233 | 		{ "ImGuiInputTextFlags_AllowTabInput", ImGuiInputTextFlags_AllowTabInput },
234 | 		{ "ImGuiInputTextFlags_CtrlEnterForNewLine", ImGuiInputTextFlags_CtrlEnterForNewLine },
235 | 		{ "ImGuiInputTextFlags_NoHorizontalScroll", ImGuiInputTextFlags_NoHorizontalScroll },
236 | 		{ "ImGuiInputTextFlags_AlwaysOverwrite", ImGuiInputTextFlags_AlwaysOverwrite },
237 | 		{ "ImGuiInputTextFlags_ReadOnly", ImGuiInputTextFlags_ReadOnly },
238 | 		{ "ImGuiInputTextFlags_Password", ImGuiInputTextFlags_Password },
239 | 		{ "ImGuiInputTextFlags_NoUndoRedo", ImGuiInputTextFlags_NoUndoRedo },
240 | 		{ "ImGuiInputTextFlags_CharsScientific", ImGuiInputTextFlags_CharsScientific },
241 | 		{ "ImGuiInputTextFlags_CallbackResize", ImGuiInputTextFlags_CallbackResize },
242 | 		{ "ImGuiInputTextFlags_CallbackEdit", ImGuiInputTextFlags_CallbackEdit },
243 | 		{ "ImGuiInputTextFlags_Multiline", ImGuiInputTextFlags_Multiline },
244 | 		{ "ImGuiInputTextFlags_NoMarkEdited", ImGuiInputTextFlags_NoMarkEdited },
245 | 
246 | 		//TreeNode Flags
247 | 		{ "ImGuiTreeNodeFlags_None", ImGuiTreeNodeFlags_None },
248 | 		{ "ImGuiTreeNodeFlags_Selected", ImGuiTreeNodeFlags_Selected },
249 | 		{ "ImGuiTreeNodeFlags_Framed", ImGuiTreeNodeFlags_Framed },
250 | 		{ "ImGuiTreeNodeFlags_AllowItemOverlap", ImGuiTreeNodeFlags_AllowItemOverlap },
251 | 		{ "ImGuiTreeNodeFlags_NoTreePushOnOpen", ImGuiTreeNodeFlags_NoTreePushOnOpen },
252 | 		{ "ImGuiTreeNodeFlags_NoAutoOpenOnLog", ImGuiTreeNodeFlags_NoAutoOpenOnLog },
253 | 		{ "ImGuiTreeNodeFlags_DefaultOpen", ImGuiTreeNodeFlags_DefaultOpen },
254 | 		{ "ImGuiTreeNodeFlags_OpenOnDoubleClick", ImGuiTreeNodeFlags_OpenOnDoubleClick },
255 | 		{ "ImGuiTreeNodeFlags_OpenOnArrow", ImGuiTreeNodeFlags_OpenOnArrow },
256 | 		{ "ImGuiTreeNodeFlags_Leaf", ImGuiTreeNodeFlags_Leaf },
257 | 		{ "ImGuiTreeNodeFlags_Bullet", ImGuiTreeNodeFlags_Bullet },
258 | 		{ "ImGuiTreeNodeFlags_FramePadding", ImGuiTreeNodeFlags_FramePadding },
259 | 		{ "ImGuiTreeNodeFlags_SpanAvailWidth", ImGuiTreeNodeFlags_SpanAvailWidth },
260 | 		{ "ImGuiTreeNodeFlags_SpanFullWidth", ImGuiTreeNodeFlags_SpanFullWidth },
261 | 		{ "ImGuiTreeNodeFlags_NavLeftJumpsBackHere", ImGuiTreeNodeFlags_NavLeftJumpsBackHere },
262 | 		{ "ImGuiTreeNodeFlags_CollapsingHeader", ImGuiTreeNodeFlags_CollapsingHeader },
263 | 
264 | 		//enum ImGuiPopupFlags_
265 | 		{ "ImGuiPopupFlags_None", ImGuiPopupFlags_None },
266 | 		{ "ImGuiPopupFlags_MouseButtonLeft", ImGuiPopupFlags_MouseButtonLeft },
267 | 		{ "ImGuiPopupFlags_MouseButtonRight", ImGuiPopupFlags_MouseButtonRight },
268 | 		{ "ImGuiPopupFlags_MouseButtonMiddle", ImGuiPopupFlags_MouseButtonMiddle },
269 | 		{ "ImGuiPopupFlags_MouseButtonMask_", ImGuiPopupFlags_MouseButtonMask_ },
270 | 		{ "ImGuiPopupFlags_MouseButtonDefault_", ImGuiPopupFlags_MouseButtonDefault_ },
271 | 		{ "ImGuiPopupFlags_NoOpenOverExistingPopup", ImGuiPopupFlags_NoOpenOverExistingPopup },
272 | 		{ "ImGuiPopupFlags_NoOpenOverItems", ImGuiPopupFlags_NoOpenOverItems },
273 | 		{ "ImGuiPopupFlags_AnyPopupId", ImGuiPopupFlags_AnyPopupId },
274 | 		{ "ImGuiPopupFlags_AnyPopupLevel", ImGuiPopupFlags_AnyPopupLevel },
275 | 		{ "ImGuiPopupFlags_AnyPopup", ImGuiPopupFlags_AnyPopup },
276 | 		//enum ImGuiSelectableFlags_
277 | 		{ "ImGuiSelectableFlags_None", ImGuiSelectableFlags_None },
278 | 		{ "ImGuiSelectableFlags_DontClosePopups", ImGuiSelectableFlags_DontClosePopups },
279 | 		{ "ImGuiSelectableFlags_SpanAllColumns", ImGuiSelectableFlags_SpanAllColumns },
280 | 		{ "ImGuiSelectableFlags_AllowDoubleClick", ImGuiSelectableFlags_AllowDoubleClick },
281 | 		{ "ImGuiSelectableFlags_Disabled", ImGuiSelectableFlags_Disabled },
282 | 		{ "ImGuiSelectableFlags_AllowItemOverlap", ImGuiSelectableFlags_AllowItemOverlap },
283 | 		//enum ImGuiComboFlags_
284 | 		{ "ImGuiComboFlags_None", ImGuiComboFlags_None },
285 | 		{ "ImGuiComboFlags_PopupAlignLeft", ImGuiComboFlags_PopupAlignLeft },
286 | 		{ "ImGuiComboFlags_HeightSmall", ImGuiComboFlags_HeightSmall },
287 | 		{ "ImGuiComboFlags_HeightRegular", ImGuiComboFlags_HeightRegular },
288 | 		{ "ImGuiComboFlags_HeightLarge", ImGuiComboFlags_HeightLarge },
289 | 		{ "ImGuiComboFlags_HeightLargest", ImGuiComboFlags_HeightLargest },
290 | 		{ "ImGuiComboFlags_NoArrowButton", ImGuiComboFlags_NoArrowButton },
291 | 		{ "ImGuiComboFlags_NoPreview", ImGuiComboFlags_NoPreview },
292 | 		{ "ImGuiComboFlags_HeightMask_", ImGuiComboFlags_HeightMask_ },
293 | 		//enum ImGuiTabBarFlags_
294 | 		{ "ImGuiTabBarFlags_None", ImGuiTabBarFlags_None },
295 | 		{ "ImGuiTabBarFlags_Reorderable", ImGuiTabBarFlags_Reorderable },
296 | 		{ "ImGuiTabBarFlags_AutoSelectNewTabs", ImGuiTabBarFlags_AutoSelectNewTabs },
297 | 		{ "ImGuiTabBarFlags_TabListPopupButton", ImGuiTabBarFlags_TabListPopupButton },
298 | 		{ "ImGuiTabBarFlags_NoCloseWithMiddleMouseButton", ImGuiTabBarFlags_NoCloseWithMiddleMouseButton },
299 | 		{ "ImGuiTabBarFlags_NoTabListScrollingButtons", ImGuiTabBarFlags_NoTabListScrollingButtons },
300 | 		{ "ImGuiTabBarFlags_NoTooltip", ImGuiTabBarFlags_NoTooltip },
301 | 		{ "ImGuiTabBarFlags_FittingPolicyResizeDown", ImGuiTabBarFlags_FittingPolicyResizeDown },
302 | 		{ "ImGuiTabBarFlags_FittingPolicyScroll", ImGuiTabBarFlags_FittingPolicyScroll },
303 | 		{ "ImGuiTabBarFlags_FittingPolicyMask_", ImGuiTabBarFlags_FittingPolicyMask_ },
304 | 		{ "ImGuiTabBarFlags_FittingPolicyDefault_", ImGuiTabBarFlags_FittingPolicyDefault_ },
305 | 		//enum ImGuiTabItemFlags_
306 | 		{ "ImGuiTabItemFlags_None", ImGuiTabItemFlags_None },
307 | 		{ "ImGuiTabItemFlags_UnsavedDocument", ImGuiTabItemFlags_UnsavedDocument },
308 | 		{ "ImGuiTabItemFlags_SetSelected", ImGuiTabItemFlags_SetSelected },
309 | 		{ "ImGuiTabItemFlags_NoCloseWithMiddleMouseButton", ImGuiTabItemFlags_NoCloseWithMiddleMouseButton },
310 | 		{ "ImGuiTabItemFlags_NoPushId", ImGuiTabItemFlags_NoPushId },
311 | 		{ "ImGuiTabItemFlags_NoTooltip", ImGuiTabItemFlags_NoTooltip },
312 | 		{ "ImGuiTabItemFlags_NoReorder", ImGuiTabItemFlags_NoReorder },
313 | 		{ "ImGuiTabItemFlags_Leading", ImGuiTabItemFlags_Leading },
314 | 		{ "ImGuiTabItemFlags_Trailing", ImGuiTabItemFlags_Trailing },
315 | 		//enum ImGuiFocusedFlags_
316 | 		{ "ImGuiFocusedFlags_None", ImGuiFocusedFlags_None },
317 | 		{ "ImGuiFocusedFlags_ChildWindows", ImGuiFocusedFlags_ChildWindows },
318 | 		{ "ImGuiFocusedFlags_RootWindow", ImGuiFocusedFlags_RootWindow },
319 | 		{ "ImGuiFocusedFlags_AnyWindow", ImGuiFocusedFlags_AnyWindow },
320 | 		{ "ImGuiFocusedFlags_RootAndChildWindows", ImGuiFocusedFlags_RootAndChildWindows },
321 | 		//enum ImGuiHoveredFlags_
322 | 		{ "ImGuiHoveredFlags_None", ImGuiHoveredFlags_None },
323 | 		{ "ImGuiHoveredFlags_ChildWindows", ImGuiHoveredFlags_ChildWindows },
324 | 		{ "ImGuiHoveredFlags_RootWindow", ImGuiHoveredFlags_RootWindow },
325 | 		{ "ImGuiHoveredFlags_AnyWindow", ImGuiHoveredFlags_AnyWindow },
326 | 		{ "ImGuiHoveredFlags_AllowWhenBlockedByPopup", ImGuiHoveredFlags_AllowWhenBlockedByPopup },
327 | 		{ "ImGuiHoveredFlags_AllowWhenBlockedByActiveItem", ImGuiHoveredFlags_AllowWhenBlockedByActiveItem },
328 | 		{ "ImGuiHoveredFlags_AllowWhenOverlapped", ImGuiHoveredFlags_AllowWhenOverlapped },
329 | 		{ "ImGuiHoveredFlags_AllowWhenDisabled", ImGuiHoveredFlags_AllowWhenDisabled },
330 | 		{ "ImGuiHoveredFlags_RectOnly", ImGuiHoveredFlags_RectOnly },
331 | 		{ "ImGuiHoveredFlags_RootAndChildWindows", ImGuiHoveredFlags_RootAndChildWindows },
332 | 		//enum ImGuiDragDropFlags_
333 | 		{ "ImGuiDragDropFlags_None", ImGuiDragDropFlags_None },
334 | 		{ "ImGuiDragDropFlags_SourceNoPreviewTooltip", ImGuiDragDropFlags_SourceNoPreviewTooltip },
335 | 		{ "ImGuiDragDropFlags_SourceNoDisableHover", ImGuiDragDropFlags_SourceNoDisableHover },
336 | 		{ "ImGuiDragDropFlags_SourceNoHoldToOpenOthers", ImGuiDragDropFlags_SourceNoHoldToOpenOthers },
337 | 		{ "ImGuiDragDropFlags_SourceAllowNullID", ImGuiDragDropFlags_SourceAllowNullID },
338 | 		{ "ImGuiDragDropFlags_SourceExtern", ImGuiDragDropFlags_SourceExtern },
339 | 		{ "ImGuiDragDropFlags_SourceAutoExpirePayload", ImGuiDragDropFlags_SourceAutoExpirePayload },
340 | 		{ "ImGuiDragDropFlags_AcceptBeforeDelivery", ImGuiDragDropFlags_AcceptBeforeDelivery },
341 | 		{ "ImGuiDragDropFlags_AcceptNoDrawDefaultRect", ImGuiDragDropFlags_AcceptNoDrawDefaultRect },
342 | 		{ "ImGuiDragDropFlags_AcceptNoPreviewTooltip", ImGuiDragDropFlags_AcceptNoPreviewTooltip },
343 | 		{ "ImGuiDragDropFlags_AcceptPeekOnly", ImGuiDragDropFlags_AcceptPeekOnly },
344 | 	};
345 | }
346 | 
347 | 
348 | #endif /* XMLREADER_H */
349 | 


--------------------------------------------------------------------------------
/includes/ImGUI/imstb_rectpack.h:
--------------------------------------------------------------------------------
  1 | // [DEAR IMGUI]
  2 | // This is a slightly modified version of stb_rect_pack.h 1.01.
  3 | // Grep for [DEAR IMGUI] to find the changes.
  4 | // 
  5 | // stb_rect_pack.h - v1.01 - public domain - rectangle packing
  6 | // Sean Barrett 2014
  7 | //
  8 | // Useful for e.g. packing rectangular textures into an atlas.
  9 | // Does not do rotation.
 10 | //
 11 | // Before #including,
 12 | //
 13 | //    #define STB_RECT_PACK_IMPLEMENTATION
 14 | //
 15 | // in the file that you want to have the implementation.
 16 | //
 17 | // Not necessarily the awesomest packing method, but better than
 18 | // the totally naive one in stb_truetype (which is primarily what
 19 | // this is meant to replace).
 20 | //
 21 | // Has only had a few tests run, may have issues.
 22 | //
 23 | // More docs to come.
 24 | //
 25 | // No memory allocations; uses qsort() and assert() from stdlib.
 26 | // Can override those by defining STBRP_SORT and STBRP_ASSERT.
 27 | //
 28 | // This library currently uses the Skyline Bottom-Left algorithm.
 29 | //
 30 | // Please note: better rectangle packers are welcome! Please
 31 | // implement them to the same API, but with a different init
 32 | // function.
 33 | //
 34 | // Credits
 35 | //
 36 | //  Library
 37 | //    Sean Barrett
 38 | //  Minor features
 39 | //    Martins Mozeiko
 40 | //    github:IntellectualKitty
 41 | //
 42 | //  Bugfixes / warning fixes
 43 | //    Jeremy Jaussaud
 44 | //    Fabian Giesen
 45 | //
 46 | // Version history:
 47 | //
 48 | //     1.01  (2021-07-11)  always use large rect mode, expose STBRP__MAXVAL in public section
 49 | //     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
 50 | //     0.99  (2019-02-07)  warning fixes
 51 | //     0.11  (2017-03-03)  return packing success/fail result
 52 | //     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
 53 | //     0.09  (2016-08-27)  fix compiler warnings
 54 | //     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
 55 | //     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
 56 | //     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
 57 | //     0.05:  added STBRP_ASSERT to allow replacing assert
 58 | //     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
 59 | //     0.01:  initial release
 60 | //
 61 | // LICENSE
 62 | //
 63 | //   See end of file for license information.
 64 | 
 65 | //////////////////////////////////////////////////////////////////////////////
 66 | //
 67 | //       INCLUDE SECTION
 68 | //
 69 | 
 70 | #ifndef STB_INCLUDE_STB_RECT_PACK_H
 71 | #define STB_INCLUDE_STB_RECT_PACK_H
 72 | 
 73 | #define STB_RECT_PACK_VERSION  1
 74 | 
 75 | #ifdef STBRP_STATIC
 76 | #define STBRP_DEF static
 77 | #else
 78 | #define STBRP_DEF extern
 79 | #endif
 80 | 
 81 | #ifdef __cplusplus
 82 | extern "C" {
 83 | #endif
 84 | 
 85 | typedef struct stbrp_context stbrp_context;
 86 | typedef struct stbrp_node    stbrp_node;
 87 | typedef struct stbrp_rect    stbrp_rect;
 88 | 
 89 | typedef int            stbrp_coord;
 90 | 
 91 | #define STBRP__MAXVAL  0x7fffffff
 92 | // Mostly for internal use, but this is the maximum supported coordinate value.
 93 | 
 94 | STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
 95 | // Assign packed locations to rectangles. The rectangles are of type
 96 | // 'stbrp_rect' defined below, stored in the array 'rects', and there
 97 | // are 'num_rects' many of them.
 98 | //
 99 | // Rectangles which are successfully packed have the 'was_packed' flag
100 | // set to a non-zero value and 'x' and 'y' store the minimum location
101 | // on each axis (i.e. bottom-left in cartesian coordinates, top-left
102 | // if you imagine y increasing downwards). Rectangles which do not fit
103 | // have the 'was_packed' flag set to 0.
104 | //
105 | // You should not try to access the 'rects' array from another thread
106 | // while this function is running, as the function temporarily reorders
107 | // the array while it executes.
108 | //
109 | // To pack into another rectangle, you need to call stbrp_init_target
110 | // again. To continue packing into the same rectangle, you can call
111 | // this function again. Calling this multiple times with multiple rect
112 | // arrays will probably produce worse packing results than calling it
113 | // a single time with the full rectangle array, but the option is
114 | // available.
115 | //
116 | // The function returns 1 if all of the rectangles were successfully
117 | // packed and 0 otherwise.
118 | 
119 | struct stbrp_rect
120 | {
121 |    // reserved for your use:
122 |    int            id;
123 | 
124 |    // input:
125 |    stbrp_coord    w, h;
126 | 
127 |    // output:
128 |    stbrp_coord    x, y;
129 |    int            was_packed;  // non-zero if valid packing
130 | 
131 | }; // 16 bytes, nominally
132 | 
133 | 
134 | STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
135 | // Initialize a rectangle packer to:
136 | //    pack a rectangle that is 'width' by 'height' in dimensions
137 | //    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
138 | //
139 | // You must call this function every time you start packing into a new target.
140 | //
141 | // There is no "shutdown" function. The 'nodes' memory must stay valid for
142 | // the following stbrp_pack_rects() call (or calls), but can be freed after
143 | // the call (or calls) finish.
144 | //
145 | // Note: to guarantee best results, either:
146 | //       1. make sure 'num_nodes' >= 'width'
147 | //   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
148 | //
149 | // If you don't do either of the above things, widths will be quantized to multiples
150 | // of small integers to guarantee the algorithm doesn't run out of temporary storage.
151 | //
152 | // If you do #2, then the non-quantized algorithm will be used, but the algorithm
153 | // may run out of temporary storage and be unable to pack some rectangles.
154 | 
155 | STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
156 | // Optionally call this function after init but before doing any packing to
157 | // change the handling of the out-of-temp-memory scenario, described above.
158 | // If you call init again, this will be reset to the default (false).
159 | 
160 | 
161 | STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
162 | // Optionally select which packing heuristic the library should use. Different
163 | // heuristics will produce better/worse results for different data sets.
164 | // If you call init again, this will be reset to the default.
165 | 
166 | enum
167 | {
168 |    STBRP_HEURISTIC_Skyline_default=0,
169 |    STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
170 |    STBRP_HEURISTIC_Skyline_BF_sortHeight
171 | };
172 | 
173 | 
174 | //////////////////////////////////////////////////////////////////////////////
175 | //
176 | // the details of the following structures don't matter to you, but they must
177 | // be visible so you can handle the memory allocations for them
178 | 
179 | struct stbrp_node
180 | {
181 |    stbrp_coord  x,y;
182 |    stbrp_node  *next;
183 | };
184 | 
185 | struct stbrp_context
186 | {
187 |    int width;
188 |    int height;
189 |    int align;
190 |    int init_mode;
191 |    int heuristic;
192 |    int num_nodes;
193 |    stbrp_node *active_head;
194 |    stbrp_node *free_head;
195 |    stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
196 | };
197 | 
198 | #ifdef __cplusplus
199 | }
200 | #endif
201 | 
202 | #endif
203 | 
204 | //////////////////////////////////////////////////////////////////////////////
205 | //
206 | //     IMPLEMENTATION SECTION
207 | //
208 | 
209 | #ifdef STB_RECT_PACK_IMPLEMENTATION
210 | #ifndef STBRP_SORT
211 | #include <stdlib.h>
212 | #define STBRP_SORT qsort
213 | #endif
214 | 
215 | #ifndef STBRP_ASSERT
216 | #include <assert.h>
217 | #define STBRP_ASSERT assert
218 | #endif
219 | 
220 | #ifdef _MSC_VER
221 | #define STBRP__NOTUSED(v)  (void)(v)
222 | #define STBRP__CDECL       __cdecl
223 | #else
224 | #define STBRP__NOTUSED(v)  (void)sizeof(v)
225 | #define STBRP__CDECL
226 | #endif
227 | 
228 | enum
229 | {
230 |    STBRP__INIT_skyline = 1
231 | };
232 | 
233 | STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
234 | {
235 |    switch (context->init_mode) {
236 |       case STBRP__INIT_skyline:
237 |          STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
238 |          context->heuristic = heuristic;
239 |          break;
240 |       default:
241 |          STBRP_ASSERT(0);
242 |    }
243 | }
244 | 
245 | STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
246 | {
247 |    if (allow_out_of_mem)
248 |       // if it's ok to run out of memory, then don't bother aligning them;
249 |       // this gives better packing, but may fail due to OOM (even though
250 |       // the rectangles easily fit). @TODO a smarter approach would be to only
251 |       // quantize once we've hit OOM, then we could get rid of this parameter.
252 |       context->align = 1;
253 |    else {
254 |       // if it's not ok to run out of memory, then quantize the widths
255 |       // so that num_nodes is always enough nodes.
256 |       //
257 |       // I.e. num_nodes * align >= width
258 |       //                  align >= width / num_nodes
259 |       //                  align = ceil(width/num_nodes)
260 | 
261 |       context->align = (context->width + context->num_nodes-1) / context->num_nodes;
262 |    }
263 | }
264 | 
265 | STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
266 | {
267 |    int i;
268 | 
269 |    for (i=0; i < num_nodes-1; ++i)
270 |       nodes[i].next = &nodes[i+1];
271 |    nodes[i].next = NULL;
272 |    context->init_mode = STBRP__INIT_skyline;
273 |    context->heuristic = STBRP_HEURISTIC_Skyline_default;
274 |    context->free_head = &nodes[0];
275 |    context->active_head = &context->extra[0];
276 |    context->width = width;
277 |    context->height = height;
278 |    context->num_nodes = num_nodes;
279 |    stbrp_setup_allow_out_of_mem(context, 0);
280 | 
281 |    // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
282 |    context->extra[0].x = 0;
283 |    context->extra[0].y = 0;
284 |    context->extra[0].next = &context->extra[1];
285 |    context->extra[1].x = (stbrp_coord) width;
286 |    context->extra[1].y = (1<<30);
287 |    context->extra[1].next = NULL;
288 | }
289 | 
290 | // find minimum y position if it starts at x1
291 | static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
292 | {
293 |    stbrp_node *node = first;
294 |    int x1 = x0 + width;
295 |    int min_y, visited_width, waste_area;
296 | 
297 |    STBRP__NOTUSED(c);
298 | 
299 |    STBRP_ASSERT(first->x <= x0);
300 | 
301 |    #if 0
302 |    // skip in case we're past the node
303 |    while (node->next->x <= x0)
304 |       ++node;
305 |    #else
306 |    STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
307 |    #endif
308 | 
309 |    STBRP_ASSERT(node->x <= x0);
310 | 
311 |    min_y = 0;
312 |    waste_area = 0;
313 |    visited_width = 0;
314 |    while (node->x < x1) {
315 |       if (node->y > min_y) {
316 |          // raise min_y higher.
317 |          // we've accounted for all waste up to min_y,
318 |          // but we'll now add more waste for everything we've visted
319 |          waste_area += visited_width * (node->y - min_y);
320 |          min_y = node->y;
321 |          // the first time through, visited_width might be reduced
322 |          if (node->x < x0)
323 |             visited_width += node->next->x - x0;
324 |          else
325 |             visited_width += node->next->x - node->x;
326 |       } else {
327 |          // add waste area
328 |          int under_width = node->next->x - node->x;
329 |          if (under_width + visited_width > width)
330 |             under_width = width - visited_width;
331 |          waste_area += under_width * (min_y - node->y);
332 |          visited_width += under_width;
333 |       }
334 |       node = node->next;
335 |    }
336 | 
337 |    *pwaste = waste_area;
338 |    return min_y;
339 | }
340 | 
341 | typedef struct
342 | {
343 |    int x,y;
344 |    stbrp_node **prev_link;
345 | } stbrp__findresult;
346 | 
347 | static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
348 | {
349 |    int best_waste = (1<<30), best_x, best_y = (1 << 30);
350 |    stbrp__findresult fr;
351 |    stbrp_node **prev, *node, *tail, **best = NULL;
352 | 
353 |    // align to multiple of c->align
354 |    width = (width + c->align - 1);
355 |    width -= width % c->align;
356 |    STBRP_ASSERT(width % c->align == 0);
357 | 
358 |    // if it can't possibly fit, bail immediately
359 |    if (width > c->width || height > c->height) {
360 |       fr.prev_link = NULL;
361 |       fr.x = fr.y = 0;
362 |       return fr;
363 |    }
364 | 
365 |    node = c->active_head;
366 |    prev = &c->active_head;
367 |    while (node->x + width <= c->width) {
368 |       int y,waste;
369 |       y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
370 |       if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
371 |          // bottom left
372 |          if (y < best_y) {
373 |             best_y = y;
374 |             best = prev;
375 |          }
376 |       } else {
377 |          // best-fit
378 |          if (y + height <= c->height) {
379 |             // can only use it if it first vertically
380 |             if (y < best_y || (y == best_y && waste < best_waste)) {
381 |                best_y = y;
382 |                best_waste = waste;
383 |                best = prev;
384 |             }
385 |          }
386 |       }
387 |       prev = &node->next;
388 |       node = node->next;
389 |    }
390 | 
391 |    best_x = (best == NULL) ? 0 : (*best)->x;
392 | 
393 |    // if doing best-fit (BF), we also have to try aligning right edge to each node position
394 |    //
395 |    // e.g, if fitting
396 |    //
397 |    //     ____________________
398 |    //    |____________________|
399 |    //
400 |    //            into
401 |    //
402 |    //   |                         |
403 |    //   |             ____________|
404 |    //   |____________|
405 |    //
406 |    // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
407 |    //
408 |    // This makes BF take about 2x the time
409 | 
410 |    if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
411 |       tail = c->active_head;
412 |       node = c->active_head;
413 |       prev = &c->active_head;
414 |       // find first node that's admissible
415 |       while (tail->x < width)
416 |          tail = tail->next;
417 |       while (tail) {
418 |          int xpos = tail->x - width;
419 |          int y,waste;
420 |          STBRP_ASSERT(xpos >= 0);
421 |          // find the left position that matches this
422 |          while (node->next->x <= xpos) {
423 |             prev = &node->next;
424 |             node = node->next;
425 |          }
426 |          STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
427 |          y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
428 |          if (y + height <= c->height) {
429 |             if (y <= best_y) {
430 |                if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
431 |                   best_x = xpos;
432 |                   //STBRP_ASSERT(y <= best_y); [DEAR IMGUI]
433 |                   best_y = y;
434 |                   best_waste = waste;
435 |                   best = prev;
436 |                }
437 |             }
438 |          }
439 |          tail = tail->next;
440 |       }
441 |    }
442 | 
443 |    fr.prev_link = best;
444 |    fr.x = best_x;
445 |    fr.y = best_y;
446 |    return fr;
447 | }
448 | 
449 | static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
450 | {
451 |    // find best position according to heuristic
452 |    stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
453 |    stbrp_node *node, *cur;
454 | 
455 |    // bail if:
456 |    //    1. it failed
457 |    //    2. the best node doesn't fit (we don't always check this)
458 |    //    3. we're out of memory
459 |    if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
460 |       res.prev_link = NULL;
461 |       return res;
462 |    }
463 | 
464 |    // on success, create new node
465 |    node = context->free_head;
466 |    node->x = (stbrp_coord) res.x;
467 |    node->y = (stbrp_coord) (res.y + height);
468 | 
469 |    context->free_head = node->next;
470 | 
471 |    // insert the new node into the right starting point, and
472 |    // let 'cur' point to the remaining nodes needing to be
473 |    // stiched back in
474 | 
475 |    cur = *res.prev_link;
476 |    if (cur->x < res.x) {
477 |       // preserve the existing one, so start testing with the next one
478 |       stbrp_node *next = cur->next;
479 |       cur->next = node;
480 |       cur = next;
481 |    } else {
482 |       *res.prev_link = node;
483 |    }
484 | 
485 |    // from here, traverse cur and free the nodes, until we get to one
486 |    // that shouldn't be freed
487 |    while (cur->next && cur->next->x <= res.x + width) {
488 |       stbrp_node *next = cur->next;
489 |       // move the current node to the free list
490 |       cur->next = context->free_head;
491 |       context->free_head = cur;
492 |       cur = next;
493 |    }
494 | 
495 |    // stitch the list back in
496 |    node->next = cur;
497 | 
498 |    if (cur->x < res.x + width)
499 |       cur->x = (stbrp_coord) (res.x + width);
500 | 
501 | #ifdef _DEBUG
502 |    cur = context->active_head;
503 |    while (cur->x < context->width) {
504 |       STBRP_ASSERT(cur->x < cur->next->x);
505 |       cur = cur->next;
506 |    }
507 |    STBRP_ASSERT(cur->next == NULL);
508 | 
509 |    {
510 |       int count=0;
511 |       cur = context->active_head;
512 |       while (cur) {
513 |          cur = cur->next;
514 |          ++count;
515 |       }
516 |       cur = context->free_head;
517 |       while (cur) {
518 |          cur = cur->next;
519 |          ++count;
520 |       }
521 |       STBRP_ASSERT(count == context->num_nodes+2);
522 |    }
523 | #endif
524 | 
525 |    return res;
526 | }
527 | 
528 | static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
529 | {
530 |    const stbrp_rect *p = (const stbrp_rect *) a;
531 |    const stbrp_rect *q = (const stbrp_rect *) b;
532 |    if (p->h > q->h)
533 |       return -1;
534 |    if (p->h < q->h)
535 |       return  1;
536 |    return (p->w > q->w) ? -1 : (p->w < q->w);
537 | }
538 | 
539 | static int STBRP__CDECL rect_original_order(const void *a, const void *b)
540 | {
541 |    const stbrp_rect *p = (const stbrp_rect *) a;
542 |    const stbrp_rect *q = (const stbrp_rect *) b;
543 |    return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
544 | }
545 | 
546 | STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
547 | {
548 |    int i, all_rects_packed = 1;
549 | 
550 |    // we use the 'was_packed' field internally to allow sorting/unsorting
551 |    for (i=0; i < num_rects; ++i) {
552 |       rects[i].was_packed = i;
553 |    }
554 | 
555 |    // sort according to heuristic
556 |    STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
557 | 
558 |    for (i=0; i < num_rects; ++i) {
559 |       if (rects[i].w == 0 || rects[i].h == 0) {
560 |          rects[i].x = rects[i].y = 0;  // empty rect needs no space
561 |       } else {
562 |          stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
563 |          if (fr.prev_link) {
564 |             rects[i].x = (stbrp_coord) fr.x;
565 |             rects[i].y = (stbrp_coord) fr.y;
566 |          } else {
567 |             rects[i].x = rects[i].y = STBRP__MAXVAL;
568 |          }
569 |       }
570 |    }
571 | 
572 |    // unsort
573 |    STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
574 | 
575 |    // set was_packed flags and all_rects_packed status
576 |    for (i=0; i < num_rects; ++i) {
577 |       rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
578 |       if (!rects[i].was_packed)
579 |          all_rects_packed = 0;
580 |    }
581 | 
582 |    // return the all_rects_packed status
583 |    return all_rects_packed;
584 | }
585 | #endif
586 | 
587 | /*
588 | ------------------------------------------------------------------------------
589 | This software is available under 2 licenses -- choose whichever you prefer.
590 | ------------------------------------------------------------------------------
591 | ALTERNATIVE A - MIT License
592 | Copyright (c) 2017 Sean Barrett
593 | Permission is hereby granted, free of charge, to any person obtaining a copy of
594 | this software and associated documentation files (the "Software"), to deal in
595 | the Software without restriction, including without limitation the rights to
596 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
597 | of the Software, and to permit persons to whom the Software is furnished to do
598 | so, subject to the following conditions:
599 | The above copyright notice and this permission notice shall be included in all
600 | copies or substantial portions of the Software.
601 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
602 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
603 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
604 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
605 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
606 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
607 | SOFTWARE.
608 | ------------------------------------------------------------------------------
609 | ALTERNATIVE B - Public Domain (www.unlicense.org)
610 | This is free and unencumbered software released into the public domain.
611 | Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
612 | software, either in source code form or as a compiled binary, for any purpose,
613 | commercial or non-commercial, and by any means.
614 | In jurisdictions that recognize copyright laws, the author or authors of this
615 | software dedicate any and all copyright interest in the software to the public
616 | domain. We make this dedication for the benefit of the public at large and to
617 | the detriment of our heirs and successors. We intend this dedication to be an
618 | overt act of relinquishment in perpetuity of all present and future rights to
619 | this software under copyright law.
620 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
621 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
622 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
623 | AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
624 | ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
625 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
626 | ------------------------------------------------------------------------------
627 | */
628 | 


--------------------------------------------------------------------------------
/includes/GL/gl3w.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * This file was generated with gl3w_gen.py, part of gl3w
  3 |  * (hosted at https://github.com/skaslev/gl3w)
  4 |  *
  5 |  * This is free and unencumbered software released into the public domain.
  6 |  *
  7 |  * Anyone is free to copy, modify, publish, use, compile, sell, or
  8 |  * distribute this software, either in source code form or as a compiled
  9 |  * binary, for any purpose, commercial or non-commercial, and by any
 10 |  * means.
 11 |  *
 12 |  * In jurisdictions that recognize copyright laws, the author or authors
 13 |  * of this software dedicate any and all copyright interest in the
 14 |  * software to the public domain. We make this dedication for the benefit
 15 |  * of the public at large and to the detriment of our heirs and
 16 |  * successors. We intend this dedication to be an overt act of
 17 |  * relinquishment in perpetuity of all present and future rights to this
 18 |  * software under copyright law.
 19 |  *
 20 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 21 |  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 22 |  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 23 |  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 24 |  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 25 |  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 26 |  * OTHER DEALINGS IN THE SOFTWARE.
 27 |  */
 28 | 
 29 | #include <GL/gl3w.h>
 30 | #include <stdlib.h>
 31 | 
 32 | #define ARRAY_SIZE(x)  (sizeof(x) / sizeof((x)[0]))
 33 | 
 34 | #if defined(_WIN32)
 35 | #ifndef WIN32_LEAN_AND_MEAN
 36 | #define WIN32_LEAN_AND_MEAN 1 // Exclude advanced Windows headers
 37 | #endif // WIN32_LEAN_AND_MEAN
 38 | #include <windows.h>
 39 | 
 40 | static HMODULE libgl;
 41 | static PROC (__stdcall *wgl_get_proc_address)(LPCSTR);
 42 | 
 43 | static int open_libgl(void)
 44 | {
 45 | 	libgl = LoadLibraryA("opengl32.dll");
 46 | 	if (!libgl)
 47 | 		return GL3W_ERROR_LIBRARY_OPEN;
 48 | 
 49 | 	*(void **)(&wgl_get_proc_address) = GetProcAddress(libgl, "wglGetProcAddress");
 50 | 	return GL3W_OK;
 51 | }
 52 | 
 53 | static void close_libgl(void)
 54 | {
 55 | 	FreeLibrary(libgl);
 56 | }
 57 | 
 58 | static GL3WglProc get_proc(const char *proc)
 59 | {
 60 | 	GL3WglProc res;
 61 | 
 62 | 	res = (GL3WglProc)wgl_get_proc_address(proc);
 63 | 	if (!res)
 64 | 		res = (GL3WglProc)GetProcAddress(libgl, proc);
 65 | 	return res;
 66 | }
 67 | #elif defined(__APPLE__)
 68 | #include <dlfcn.h>
 69 | 
 70 | static void *libgl;
 71 | 
 72 | static int open_libgl(void)
 73 | {
 74 | 	libgl = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY | RTLD_LOCAL);
 75 | 	if (!libgl)
 76 | 		return GL3W_ERROR_LIBRARY_OPEN;
 77 | 
 78 | 	return GL3W_OK;
 79 | }
 80 | 
 81 | static void close_libgl(void)
 82 | {
 83 | 	dlclose(libgl);
 84 | }
 85 | 
 86 | static GL3WglProc get_proc(const char *proc)
 87 | {
 88 | 	GL3WglProc res;
 89 | 
 90 | 	*(void **)(&res) = dlsym(libgl, proc);
 91 | 	return res;
 92 | }
 93 | #else
 94 | #include <dlfcn.h>
 95 | 
 96 | static void *libgl;
 97 | static GL3WglProc (*glx_get_proc_address)(const GLubyte *);
 98 | 
 99 | static int open_libgl(void)
100 | {
101 | 	libgl = dlopen("libGL.so.1", RTLD_LAZY | RTLD_LOCAL);
102 | 	if (!libgl)
103 | 		return GL3W_ERROR_LIBRARY_OPEN;
104 | 
105 | 	*(void **)(&glx_get_proc_address) = dlsym(libgl, "glXGetProcAddressARB");
106 | 	return GL3W_OK;
107 | }
108 | 
109 | static void close_libgl(void)
110 | {
111 | 	dlclose(libgl);
112 | }
113 | 
114 | static GL3WglProc get_proc(const char *proc)
115 | {
116 | 	GL3WglProc res;
117 | 
118 | 	res = glx_get_proc_address((const GLubyte *)proc);
119 | 	if (!res)
120 | 		*(void **)(&res) = dlsym(libgl, proc);
121 | 	return res;
122 | }
123 | #endif
124 | 
125 | static struct {
126 | 	int major, minor;
127 | } version;
128 | 
129 | static int parse_version(void)
130 | {
131 | 	if (!glGetIntegerv)
132 | 		return GL3W_ERROR_INIT;
133 | 
134 | 	glGetIntegerv(GL_MAJOR_VERSION, &version.major);
135 | 	glGetIntegerv(GL_MINOR_VERSION, &version.minor);
136 | 
137 | 	if (version.major < 3)
138 | 		return GL3W_ERROR_OPENGL_VERSION;
139 | 	return GL3W_OK;
140 | }
141 | 
142 | static void load_procs(GL3WGetProcAddressProc proc);
143 | 
144 | int gl3wInit(void)
145 | {
146 | 	int res;
147 | 
148 | 	res = open_libgl();
149 | 	if (res)
150 | 		return res;
151 | 
152 | 	atexit(close_libgl);
153 | 	return gl3wInit2(get_proc);
154 | }
155 | 
156 | int gl3wInit2(GL3WGetProcAddressProc proc)
157 | {
158 | 	load_procs(proc);
159 | 	return parse_version();
160 | }
161 | 
162 | int gl3wIsSupported(int major, int minor)
163 | {
164 | 	if (major < 3)
165 | 		return 0;
166 | 	if (version.major == major)
167 | 		return version.minor >= minor;
168 | 	return version.major >= major;
169 | }
170 | 
171 | GL3WglProc gl3wGetProcAddress(const char *proc)
172 | {
173 | 	return get_proc(proc);
174 | }
175 | 
176 | static const char *proc_names[] = {
177 | 	"glActiveShaderProgram",
178 | 	"glActiveTexture",
179 | 	"glAttachShader",
180 | 	"glBeginConditionalRender",
181 | 	"glBeginQuery",
182 | 	"glBeginQueryIndexed",
183 | 	"glBeginTransformFeedback",
184 | 	"glBindAttribLocation",
185 | 	"glBindBuffer",
186 | 	"glBindBufferBase",
187 | 	"glBindBufferRange",
188 | 	"glBindBuffersBase",
189 | 	"glBindBuffersRange",
190 | 	"glBindFragDataLocation",
191 | 	"glBindFragDataLocationIndexed",
192 | 	"glBindFramebuffer",
193 | 	"glBindImageTexture",
194 | 	"glBindImageTextures",
195 | 	"glBindProgramPipeline",
196 | 	"glBindRenderbuffer",
197 | 	"glBindSampler",
198 | 	"glBindSamplers",
199 | 	"glBindTexture",
200 | 	"glBindTextureUnit",
201 | 	"glBindTextures",
202 | 	"glBindTransformFeedback",
203 | 	"glBindVertexArray",
204 | 	"glBindVertexBuffer",
205 | 	"glBindVertexBuffers",
206 | 	"glBlendColor",
207 | 	"glBlendEquation",
208 | 	"glBlendEquationSeparate",
209 | 	"glBlendEquationSeparatei",
210 | 	"glBlendEquationi",
211 | 	"glBlendFunc",
212 | 	"glBlendFuncSeparate",
213 | 	"glBlendFuncSeparatei",
214 | 	"glBlendFunci",
215 | 	"glBlitFramebuffer",
216 | 	"glBlitNamedFramebuffer",
217 | 	"glBufferData",
218 | 	"glBufferStorage",
219 | 	"glBufferSubData",
220 | 	"glCheckFramebufferStatus",
221 | 	"glCheckNamedFramebufferStatus",
222 | 	"glClampColor",
223 | 	"glClear",
224 | 	"glClearBufferData",
225 | 	"glClearBufferSubData",
226 | 	"glClearBufferfi",
227 | 	"glClearBufferfv",
228 | 	"glClearBufferiv",
229 | 	"glClearBufferuiv",
230 | 	"glClearColor",
231 | 	"glClearDepth",
232 | 	"glClearDepthf",
233 | 	"glClearNamedBufferData",
234 | 	"glClearNamedBufferSubData",
235 | 	"glClearNamedFramebufferfi",
236 | 	"glClearNamedFramebufferfv",
237 | 	"glClearNamedFramebufferiv",
238 | 	"glClearNamedFramebufferuiv",
239 | 	"glClearStencil",
240 | 	"glClearTexImage",
241 | 	"glClearTexSubImage",
242 | 	"glClientWaitSync",
243 | 	"glClipControl",
244 | 	"glColorMask",
245 | 	"glColorMaski",
246 | 	"glCompileShader",
247 | 	"glCompressedTexImage1D",
248 | 	"glCompressedTexImage2D",
249 | 	"glCompressedTexImage3D",
250 | 	"glCompressedTexSubImage1D",
251 | 	"glCompressedTexSubImage2D",
252 | 	"glCompressedTexSubImage3D",
253 | 	"glCompressedTextureSubImage1D",
254 | 	"glCompressedTextureSubImage2D",
255 | 	"glCompressedTextureSubImage3D",
256 | 	"glCopyBufferSubData",
257 | 	"glCopyImageSubData",
258 | 	"glCopyNamedBufferSubData",
259 | 	"glCopyTexImage1D",
260 | 	"glCopyTexImage2D",
261 | 	"glCopyTexSubImage1D",
262 | 	"glCopyTexSubImage2D",
263 | 	"glCopyTexSubImage3D",
264 | 	"glCopyTextureSubImage1D",
265 | 	"glCopyTextureSubImage2D",
266 | 	"glCopyTextureSubImage3D",
267 | 	"glCreateBuffers",
268 | 	"glCreateFramebuffers",
269 | 	"glCreateProgram",
270 | 	"glCreateProgramPipelines",
271 | 	"glCreateQueries",
272 | 	"glCreateRenderbuffers",
273 | 	"glCreateSamplers",
274 | 	"glCreateShader",
275 | 	"glCreateShaderProgramv",
276 | 	"glCreateTextures",
277 | 	"glCreateTransformFeedbacks",
278 | 	"glCreateVertexArrays",
279 | 	"glCullFace",
280 | 	"glDebugMessageCallback",
281 | 	"glDebugMessageControl",
282 | 	"glDebugMessageInsert",
283 | 	"glDeleteBuffers",
284 | 	"glDeleteFramebuffers",
285 | 	"glDeleteProgram",
286 | 	"glDeleteProgramPipelines",
287 | 	"glDeleteQueries",
288 | 	"glDeleteRenderbuffers",
289 | 	"glDeleteSamplers",
290 | 	"glDeleteShader",
291 | 	"glDeleteSync",
292 | 	"glDeleteTextures",
293 | 	"glDeleteTransformFeedbacks",
294 | 	"glDeleteVertexArrays",
295 | 	"glDepthFunc",
296 | 	"glDepthMask",
297 | 	"glDepthRange",
298 | 	"glDepthRangeArrayv",
299 | 	"glDepthRangeIndexed",
300 | 	"glDepthRangef",
301 | 	"glDetachShader",
302 | 	"glDisable",
303 | 	"glDisableVertexArrayAttrib",
304 | 	"glDisableVertexAttribArray",
305 | 	"glDisablei",
306 | 	"glDispatchCompute",
307 | 	"glDispatchComputeIndirect",
308 | 	"glDrawArrays",
309 | 	"glDrawArraysIndirect",
310 | 	"glDrawArraysInstanced",
311 | 	"glDrawArraysInstancedBaseInstance",
312 | 	"glDrawBuffer",
313 | 	"glDrawBuffers",
314 | 	"glDrawElements",
315 | 	"glDrawElementsBaseVertex",
316 | 	"glDrawElementsIndirect",
317 | 	"glDrawElementsInstanced",
318 | 	"glDrawElementsInstancedBaseInstance",
319 | 	"glDrawElementsInstancedBaseVertex",
320 | 	"glDrawElementsInstancedBaseVertexBaseInstance",
321 | 	"glDrawRangeElements",
322 | 	"glDrawRangeElementsBaseVertex",
323 | 	"glDrawTransformFeedback",
324 | 	"glDrawTransformFeedbackInstanced",
325 | 	"glDrawTransformFeedbackStream",
326 | 	"glDrawTransformFeedbackStreamInstanced",
327 | 	"glEnable",
328 | 	"glEnableVertexArrayAttrib",
329 | 	"glEnableVertexAttribArray",
330 | 	"glEnablei",
331 | 	"glEndConditionalRender",
332 | 	"glEndQuery",
333 | 	"glEndQueryIndexed",
334 | 	"glEndTransformFeedback",
335 | 	"glFenceSync",
336 | 	"glFinish",
337 | 	"glFlush",
338 | 	"glFlushMappedBufferRange",
339 | 	"glFlushMappedNamedBufferRange",
340 | 	"glFramebufferParameteri",
341 | 	"glFramebufferParameteriMESA",
342 | 	"glFramebufferRenderbuffer",
343 | 	"glFramebufferTexture",
344 | 	"glFramebufferTexture1D",
345 | 	"glFramebufferTexture2D",
346 | 	"glFramebufferTexture3D",
347 | 	"glFramebufferTextureLayer",
348 | 	"glFrontFace",
349 | 	"glGenBuffers",
350 | 	"glGenFramebuffers",
351 | 	"glGenProgramPipelines",
352 | 	"glGenQueries",
353 | 	"glGenRenderbuffers",
354 | 	"glGenSamplers",
355 | 	"glGenTextures",
356 | 	"glGenTransformFeedbacks",
357 | 	"glGenVertexArrays",
358 | 	"glGenerateMipmap",
359 | 	"glGenerateTextureMipmap",
360 | 	"glGetActiveAtomicCounterBufferiv",
361 | 	"glGetActiveAttrib",
362 | 	"glGetActiveSubroutineName",
363 | 	"glGetActiveSubroutineUniformName",
364 | 	"glGetActiveSubroutineUniformiv",
365 | 	"glGetActiveUniform",
366 | 	"glGetActiveUniformBlockName",
367 | 	"glGetActiveUniformBlockiv",
368 | 	"glGetActiveUniformName",
369 | 	"glGetActiveUniformsiv",
370 | 	"glGetAttachedShaders",
371 | 	"glGetAttribLocation",
372 | 	"glGetBooleani_v",
373 | 	"glGetBooleanv",
374 | 	"glGetBufferParameteri64v",
375 | 	"glGetBufferParameteriv",
376 | 	"glGetBufferPointerv",
377 | 	"glGetBufferSubData",
378 | 	"glGetCompressedTexImage",
379 | 	"glGetCompressedTextureImage",
380 | 	"glGetCompressedTextureSubImage",
381 | 	"glGetDebugMessageLog",
382 | 	"glGetDoublei_v",
383 | 	"glGetDoublev",
384 | 	"glGetError",
385 | 	"glGetFloati_v",
386 | 	"glGetFloatv",
387 | 	"glGetFragDataIndex",
388 | 	"glGetFragDataLocation",
389 | 	"glGetFramebufferAttachmentParameteriv",
390 | 	"glGetFramebufferParameteriv",
391 | 	"glGetFramebufferParameterivMESA",
392 | 	"glGetGraphicsResetStatus",
393 | 	"glGetInteger64i_v",
394 | 	"glGetInteger64v",
395 | 	"glGetIntegeri_v",
396 | 	"glGetIntegerv",
397 | 	"glGetInternalformati64v",
398 | 	"glGetInternalformativ",
399 | 	"glGetMultisamplefv",
400 | 	"glGetNamedBufferParameteri64v",
401 | 	"glGetNamedBufferParameteriv",
402 | 	"glGetNamedBufferPointerv",
403 | 	"glGetNamedBufferSubData",
404 | 	"glGetNamedFramebufferAttachmentParameteriv",
405 | 	"glGetNamedFramebufferParameteriv",
406 | 	"glGetNamedRenderbufferParameteriv",
407 | 	"glGetObjectLabel",
408 | 	"glGetObjectPtrLabel",
409 | 	"glGetPointerv",
410 | 	"glGetProgramBinary",
411 | 	"glGetProgramInfoLog",
412 | 	"glGetProgramInterfaceiv",
413 | 	"glGetProgramPipelineInfoLog",
414 | 	"glGetProgramPipelineiv",
415 | 	"glGetProgramResourceIndex",
416 | 	"glGetProgramResourceLocation",
417 | 	"glGetProgramResourceLocationIndex",
418 | 	"glGetProgramResourceName",
419 | 	"glGetProgramResourceiv",
420 | 	"glGetProgramStageiv",
421 | 	"glGetProgramiv",
422 | 	"glGetQueryBufferObjecti64v",
423 | 	"glGetQueryBufferObjectiv",
424 | 	"glGetQueryBufferObjectui64v",
425 | 	"glGetQueryBufferObjectuiv",
426 | 	"glGetQueryIndexediv",
427 | 	"glGetQueryObjecti64v",
428 | 	"glGetQueryObjectiv",
429 | 	"glGetQueryObjectui64v",
430 | 	"glGetQueryObjectuiv",
431 | 	"glGetQueryiv",
432 | 	"glGetRenderbufferParameteriv",
433 | 	"glGetSamplerParameterIiv",
434 | 	"glGetSamplerParameterIuiv",
435 | 	"glGetSamplerParameterfv",
436 | 	"glGetSamplerParameteriv",
437 | 	"glGetShaderInfoLog",
438 | 	"glGetShaderPrecisionFormat",
439 | 	"glGetShaderSource",
440 | 	"glGetShaderiv",
441 | 	"glGetString",
442 | 	"glGetStringi",
443 | 	"glGetSubroutineIndex",
444 | 	"glGetSubroutineUniformLocation",
445 | 	"glGetSynciv",
446 | 	"glGetTexImage",
447 | 	"glGetTexLevelParameterfv",
448 | 	"glGetTexLevelParameteriv",
449 | 	"glGetTexParameterIiv",
450 | 	"glGetTexParameterIuiv",
451 | 	"glGetTexParameterfv",
452 | 	"glGetTexParameteriv",
453 | 	"glGetTextureImage",
454 | 	"glGetTextureLevelParameterfv",
455 | 	"glGetTextureLevelParameteriv",
456 | 	"glGetTextureParameterIiv",
457 | 	"glGetTextureParameterIuiv",
458 | 	"glGetTextureParameterfv",
459 | 	"glGetTextureParameteriv",
460 | 	"glGetTextureSubImage",
461 | 	"glGetTransformFeedbackVarying",
462 | 	"glGetTransformFeedbacki64_v",
463 | 	"glGetTransformFeedbacki_v",
464 | 	"glGetTransformFeedbackiv",
465 | 	"glGetUniformBlockIndex",
466 | 	"glGetUniformIndices",
467 | 	"glGetUniformLocation",
468 | 	"glGetUniformSubroutineuiv",
469 | 	"glGetUniformdv",
470 | 	"glGetUniformfv",
471 | 	"glGetUniformiv",
472 | 	"glGetUniformuiv",
473 | 	"glGetVertexArrayIndexed64iv",
474 | 	"glGetVertexArrayIndexediv",
475 | 	"glGetVertexArrayiv",
476 | 	"glGetVertexAttribIiv",
477 | 	"glGetVertexAttribIuiv",
478 | 	"glGetVertexAttribLdv",
479 | 	"glGetVertexAttribPointerv",
480 | 	"glGetVertexAttribdv",
481 | 	"glGetVertexAttribfv",
482 | 	"glGetVertexAttribiv",
483 | 	"glGetnCompressedTexImage",
484 | 	"glGetnTexImage",
485 | 	"glGetnUniformdv",
486 | 	"glGetnUniformfv",
487 | 	"glGetnUniformiv",
488 | 	"glGetnUniformuiv",
489 | 	"glHint",
490 | 	"glInvalidateBufferData",
491 | 	"glInvalidateBufferSubData",
492 | 	"glInvalidateFramebuffer",
493 | 	"glInvalidateNamedFramebufferData",
494 | 	"glInvalidateNamedFramebufferSubData",
495 | 	"glInvalidateSubFramebuffer",
496 | 	"glInvalidateTexImage",
497 | 	"glInvalidateTexSubImage",
498 | 	"glIsBuffer",
499 | 	"glIsEnabled",
500 | 	"glIsEnabledi",
501 | 	"glIsFramebuffer",
502 | 	"glIsProgram",
503 | 	"glIsProgramPipeline",
504 | 	"glIsQuery",
505 | 	"glIsRenderbuffer",
506 | 	"glIsSampler",
507 | 	"glIsShader",
508 | 	"glIsSync",
509 | 	"glIsTexture",
510 | 	"glIsTransformFeedback",
511 | 	"glIsVertexArray",
512 | 	"glLineWidth",
513 | 	"glLinkProgram",
514 | 	"glLogicOp",
515 | 	"glMapBuffer",
516 | 	"glMapBufferRange",
517 | 	"glMapNamedBuffer",
518 | 	"glMapNamedBufferRange",
519 | 	"glMemoryBarrier",
520 | 	"glMemoryBarrierByRegion",
521 | 	"glMinSampleShading",
522 | 	"glMultiDrawArrays",
523 | 	"glMultiDrawArraysIndirect",
524 | 	"glMultiDrawArraysIndirectCount",
525 | 	"glMultiDrawElements",
526 | 	"glMultiDrawElementsBaseVertex",
527 | 	"glMultiDrawElementsIndirect",
528 | 	"glMultiDrawElementsIndirectCount",
529 | 	"glNamedBufferData",
530 | 	"glNamedBufferStorage",
531 | 	"glNamedBufferSubData",
532 | 	"glNamedFramebufferDrawBuffer",
533 | 	"glNamedFramebufferDrawBuffers",
534 | 	"glNamedFramebufferParameteri",
535 | 	"glNamedFramebufferReadBuffer",
536 | 	"glNamedFramebufferRenderbuffer",
537 | 	"glNamedFramebufferTexture",
538 | 	"glNamedFramebufferTextureLayer",
539 | 	"glNamedRenderbufferStorage",
540 | 	"glNamedRenderbufferStorageMultisample",
541 | 	"glObjectLabel",
542 | 	"glObjectPtrLabel",
543 | 	"glPatchParameterfv",
544 | 	"glPatchParameteri",
545 | 	"glPauseTransformFeedback",
546 | 	"glPixelStoref",
547 | 	"glPixelStorei",
548 | 	"glPointParameterf",
549 | 	"glPointParameterfv",
550 | 	"glPointParameteri",
551 | 	"glPointParameteriv",
552 | 	"glPointSize",
553 | 	"glPolygonMode",
554 | 	"glPolygonOffset",
555 | 	"glPolygonOffsetClamp",
556 | 	"glPopDebugGroup",
557 | 	"glPrimitiveRestartIndex",
558 | 	"glProgramBinary",
559 | 	"glProgramParameteri",
560 | 	"glProgramUniform1d",
561 | 	"glProgramUniform1dv",
562 | 	"glProgramUniform1f",
563 | 	"glProgramUniform1fv",
564 | 	"glProgramUniform1i",
565 | 	"glProgramUniform1iv",
566 | 	"glProgramUniform1ui",
567 | 	"glProgramUniform1uiv",
568 | 	"glProgramUniform2d",
569 | 	"glProgramUniform2dv",
570 | 	"glProgramUniform2f",
571 | 	"glProgramUniform2fv",
572 | 	"glProgramUniform2i",
573 | 	"glProgramUniform2iv",
574 | 	"glProgramUniform2ui",
575 | 	"glProgramUniform2uiv",
576 | 	"glProgramUniform3d",
577 | 	"glProgramUniform3dv",
578 | 	"glProgramUniform3f",
579 | 	"glProgramUniform3fv",
580 | 	"glProgramUniform3i",
581 | 	"glProgramUniform3iv",
582 | 	"glProgramUniform3ui",
583 | 	"glProgramUniform3uiv",
584 | 	"glProgramUniform4d",
585 | 	"glProgramUniform4dv",
586 | 	"glProgramUniform4f",
587 | 	"glProgramUniform4fv",
588 | 	"glProgramUniform4i",
589 | 	"glProgramUniform4iv",
590 | 	"glProgramUniform4ui",
591 | 	"glProgramUniform4uiv",
592 | 	"glProgramUniformMatrix2dv",
593 | 	"glProgramUniformMatrix2fv",
594 | 	"glProgramUniformMatrix2x3dv",
595 | 	"glProgramUniformMatrix2x3fv",
596 | 	"glProgramUniformMatrix2x4dv",
597 | 	"glProgramUniformMatrix2x4fv",
598 | 	"glProgramUniformMatrix3dv",
599 | 	"glProgramUniformMatrix3fv",
600 | 	"glProgramUniformMatrix3x2dv",
601 | 	"glProgramUniformMatrix3x2fv",
602 | 	"glProgramUniformMatrix3x4dv",
603 | 	"glProgramUniformMatrix3x4fv",
604 | 	"glProgramUniformMatrix4dv",
605 | 	"glProgramUniformMatrix4fv",
606 | 	"glProgramUniformMatrix4x2dv",
607 | 	"glProgramUniformMatrix4x2fv",
608 | 	"glProgramUniformMatrix4x3dv",
609 | 	"glProgramUniformMatrix4x3fv",
610 | 	"glProvokingVertex",
611 | 	"glPushDebugGroup",
612 | 	"glQueryCounter",
613 | 	"glReadBuffer",
614 | 	"glReadPixels",
615 | 	"glReadnPixels",
616 | 	"glReleaseShaderCompiler",
617 | 	"glRenderbufferStorage",
618 | 	"glRenderbufferStorageMultisample",
619 | 	"glResumeTransformFeedback",
620 | 	"glSampleCoverage",
621 | 	"glSampleMaski",
622 | 	"glSamplerParameterIiv",
623 | 	"glSamplerParameterIuiv",
624 | 	"glSamplerParameterf",
625 | 	"glSamplerParameterfv",
626 | 	"glSamplerParameteri",
627 | 	"glSamplerParameteriv",
628 | 	"glScissor",
629 | 	"glScissorArrayv",
630 | 	"glScissorIndexed",
631 | 	"glScissorIndexedv",
632 | 	"glShaderBinary",
633 | 	"glShaderSource",
634 | 	"glShaderStorageBlockBinding",
635 | 	"glSpecializeShader",
636 | 	"glStencilFunc",
637 | 	"glStencilFuncSeparate",
638 | 	"glStencilMask",
639 | 	"glStencilMaskSeparate",
640 | 	"glStencilOp",
641 | 	"glStencilOpSeparate",
642 | 	"glTexBuffer",
643 | 	"glTexBufferRange",
644 | 	"glTexImage1D",
645 | 	"glTexImage2D",
646 | 	"glTexImage2DMultisample",
647 | 	"glTexImage3D",
648 | 	"glTexImage3DMultisample",
649 | 	"glTexParameterIiv",
650 | 	"glTexParameterIuiv",
651 | 	"glTexParameterf",
652 | 	"glTexParameterfv",
653 | 	"glTexParameteri",
654 | 	"glTexParameteriv",
655 | 	"glTexStorage1D",
656 | 	"glTexStorage2D",
657 | 	"glTexStorage2DMultisample",
658 | 	"glTexStorage3D",
659 | 	"glTexStorage3DMultisample",
660 | 	"glTexSubImage1D",
661 | 	"glTexSubImage2D",
662 | 	"glTexSubImage3D",
663 | 	"glTextureBarrier",
664 | 	"glTextureBuffer",
665 | 	"glTextureBufferRange",
666 | 	"glTextureParameterIiv",
667 | 	"glTextureParameterIuiv",
668 | 	"glTextureParameterf",
669 | 	"glTextureParameterfv",
670 | 	"glTextureParameteri",
671 | 	"glTextureParameteriv",
672 | 	"glTextureStorage1D",
673 | 	"glTextureStorage2D",
674 | 	"glTextureStorage2DMultisample",
675 | 	"glTextureStorage3D",
676 | 	"glTextureStorage3DMultisample",
677 | 	"glTextureSubImage1D",
678 | 	"glTextureSubImage2D",
679 | 	"glTextureSubImage3D",
680 | 	"glTextureView",
681 | 	"glTransformFeedbackBufferBase",
682 | 	"glTransformFeedbackBufferRange",
683 | 	"glTransformFeedbackVaryings",
684 | 	"glUniform1d",
685 | 	"glUniform1dv",
686 | 	"glUniform1f",
687 | 	"glUniform1fv",
688 | 	"glUniform1i",
689 | 	"glUniform1iv",
690 | 	"glUniform1ui",
691 | 	"glUniform1uiv",
692 | 	"glUniform2d",
693 | 	"glUniform2dv",
694 | 	"glUniform2f",
695 | 	"glUniform2fv",
696 | 	"glUniform2i",
697 | 	"glUniform2iv",
698 | 	"glUniform2ui",
699 | 	"glUniform2uiv",
700 | 	"glUniform3d",
701 | 	"glUniform3dv",
702 | 	"glUniform3f",
703 | 	"glUniform3fv",
704 | 	"glUniform3i",
705 | 	"glUniform3iv",
706 | 	"glUniform3ui",
707 | 	"glUniform3uiv",
708 | 	"glUniform4d",
709 | 	"glUniform4dv",
710 | 	"glUniform4f",
711 | 	"glUniform4fv",
712 | 	"glUniform4i",
713 | 	"glUniform4iv",
714 | 	"glUniform4ui",
715 | 	"glUniform4uiv",
716 | 	"glUniformBlockBinding",
717 | 	"glUniformMatrix2dv",
718 | 	"glUniformMatrix2fv",
719 | 	"glUniformMatrix2x3dv",
720 | 	"glUniformMatrix2x3fv",
721 | 	"glUniformMatrix2x4dv",
722 | 	"glUniformMatrix2x4fv",
723 | 	"glUniformMatrix3dv",
724 | 	"glUniformMatrix3fv",
725 | 	"glUniformMatrix3x2dv",
726 | 	"glUniformMatrix3x2fv",
727 | 	"glUniformMatrix3x4dv",
728 | 	"glUniformMatrix3x4fv",
729 | 	"glUniformMatrix4dv",
730 | 	"glUniformMatrix4fv",
731 | 	"glUniformMatrix4x2dv",
732 | 	"glUniformMatrix4x2fv",
733 | 	"glUniformMatrix4x3dv",
734 | 	"glUniformMatrix4x3fv",
735 | 	"glUniformSubroutinesuiv",
736 | 	"glUnmapBuffer",
737 | 	"glUnmapNamedBuffer",
738 | 	"glUseProgram",
739 | 	"glUseProgramStages",
740 | 	"glValidateProgram",
741 | 	"glValidateProgramPipeline",
742 | 	"glVertexArrayAttribBinding",
743 | 	"glVertexArrayAttribFormat",
744 | 	"glVertexArrayAttribIFormat",
745 | 	"glVertexArrayAttribLFormat",
746 | 	"glVertexArrayBindingDivisor",
747 | 	"glVertexArrayElementBuffer",
748 | 	"glVertexArrayVertexBuffer",
749 | 	"glVertexArrayVertexBuffers",
750 | 	"glVertexAttrib1d",
751 | 	"glVertexAttrib1dv",
752 | 	"glVertexAttrib1f",
753 | 	"glVertexAttrib1fv",
754 | 	"glVertexAttrib1s",
755 | 	"glVertexAttrib1sv",
756 | 	"glVertexAttrib2d",
757 | 	"glVertexAttrib2dv",
758 | 	"glVertexAttrib2f",
759 | 	"glVertexAttrib2fv",
760 | 	"glVertexAttrib2s",
761 | 	"glVertexAttrib2sv",
762 | 	"glVertexAttrib3d",
763 | 	"glVertexAttrib3dv",
764 | 	"glVertexAttrib3f",
765 | 	"glVertexAttrib3fv",
766 | 	"glVertexAttrib3s",
767 | 	"glVertexAttrib3sv",
768 | 	"glVertexAttrib4Nbv",
769 | 	"glVertexAttrib4Niv",
770 | 	"glVertexAttrib4Nsv",
771 | 	"glVertexAttrib4Nub",
772 | 	"glVertexAttrib4Nubv",
773 | 	"glVertexAttrib4Nuiv",
774 | 	"glVertexAttrib4Nusv",
775 | 	"glVertexAttrib4bv",
776 | 	"glVertexAttrib4d",
777 | 	"glVertexAttrib4dv",
778 | 	"glVertexAttrib4f",
779 | 	"glVertexAttrib4fv",
780 | 	"glVertexAttrib4iv",
781 | 	"glVertexAttrib4s",
782 | 	"glVertexAttrib4sv",
783 | 	"glVertexAttrib4ubv",
784 | 	"glVertexAttrib4uiv",
785 | 	"glVertexAttrib4usv",
786 | 	"glVertexAttribBinding",
787 | 	"glVertexAttribDivisor",
788 | 	"glVertexAttribFormat",
789 | 	"glVertexAttribI1i",
790 | 	"glVertexAttribI1iv",
791 | 	"glVertexAttribI1ui",
792 | 	"glVertexAttribI1uiv",
793 | 	"glVertexAttribI2i",
794 | 	"glVertexAttribI2iv",
795 | 	"glVertexAttribI2ui",
796 | 	"glVertexAttribI2uiv",
797 | 	"glVertexAttribI3i",
798 | 	"glVertexAttribI3iv",
799 | 	"glVertexAttribI3ui",
800 | 	"glVertexAttribI3uiv",
801 | 	"glVertexAttribI4bv",
802 | 	"glVertexAttribI4i",
803 | 	"glVertexAttribI4iv",
804 | 	"glVertexAttribI4sv",
805 | 	"glVertexAttribI4ubv",
806 | 	"glVertexAttribI4ui",
807 | 	"glVertexAttribI4uiv",
808 | 	"glVertexAttribI4usv",
809 | 	"glVertexAttribIFormat",
810 | 	"glVertexAttribIPointer",
811 | 	"glVertexAttribL1d",
812 | 	"glVertexAttribL1dv",
813 | 	"glVertexAttribL2d",
814 | 	"glVertexAttribL2dv",
815 | 	"glVertexAttribL3d",
816 | 	"glVertexAttribL3dv",
817 | 	"glVertexAttribL4d",
818 | 	"glVertexAttribL4dv",
819 | 	"glVertexAttribLFormat",
820 | 	"glVertexAttribLPointer",
821 | 	"glVertexAttribP1ui",
822 | 	"glVertexAttribP1uiv",
823 | 	"glVertexAttribP2ui",
824 | 	"glVertexAttribP2uiv",
825 | 	"glVertexAttribP3ui",
826 | 	"glVertexAttribP3uiv",
827 | 	"glVertexAttribP4ui",
828 | 	"glVertexAttribP4uiv",
829 | 	"glVertexAttribPointer",
830 | 	"glVertexBindingDivisor",
831 | 	"glViewport",
832 | 	"glViewportArrayv",
833 | 	"glViewportIndexedf",
834 | 	"glViewportIndexedfv",
835 | 	"glWaitSync",
836 | };
837 | 
838 | union GL3WProcs gl3wProcs;
839 | 
840 | static void load_procs(GL3WGetProcAddressProc proc)
841 | {
842 | 	size_t i;
843 | 
844 | 	for (i = 0; i < ARRAY_SIZE(proc_names); i++)
845 | 		gl3wProcs.ptr[i] = proc(proc_names[i]);
846 | }
847 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                   GNU LESSER GENERAL PUBLIC LICENSE
  2 |                        Version 2.1, February 1999
  3 | 
  4 |  Copyright (C) 1991, 1999 Free Software Foundation, Inc.
  5 |  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 | [This is the first released version of the Lesser GPL.  It also counts
 10 |  as the successor of the GNU Library Public License, version 2, hence
 11 |  the version number 2.1.]
 12 | 
 13 |                             Preamble
 14 | 
 15 |   The licenses for most software are designed to take away your
 16 | freedom to share and change it.  By contrast, the GNU General Public
 17 | Licenses are intended to guarantee your freedom to share and change
 18 | free software--to make sure the software is free for all its users.
 19 | 
 20 |   This license, the Lesser General Public License, applies to some
 21 | specially designated software packages--typically libraries--of the
 22 | Free Software Foundation and other authors who decide to use it.  You
 23 | can use it too, but we suggest you first think carefully about whether
 24 | this license or the ordinary General Public License is the better
 25 | strategy to use in any particular case, based on the explanations below.
 26 | 
 27 |   When we speak of free software, we are referring to freedom of use,
 28 | not price.  Our General Public Licenses are designed to make sure that
 29 | you have the freedom to distribute copies of free software (and charge
 30 | for this service if you wish); that you receive source code or can get
 31 | it if you want it; that you can change the software and use pieces of
 32 | it in new free programs; and that you are informed that you can do
 33 | these things.
 34 | 
 35 |   To protect your rights, we need to make restrictions that forbid
 36 | distributors to deny you these rights or to ask you to surrender these
 37 | rights.  These restrictions translate to certain responsibilities for
 38 | you if you distribute copies of the library or if you modify it.
 39 | 
 40 |   For example, if you distribute copies of the library, whether gratis
 41 | or for a fee, you must give the recipients all the rights that we gave
 42 | you.  You must make sure that they, too, receive or can get the source
 43 | code.  If you link other code with the library, you must provide
 44 | complete object files to the recipients, so that they can relink them
 45 | with the library after making changes to the library and recompiling
 46 | it.  And you must show them these terms so they know their rights.
 47 | 
 48 |   We protect your rights with a two-step method: (1) we copyright the
 49 | library, and (2) we offer you this license, which gives you legal
 50 | permission to copy, distribute and/or modify the library.
 51 | 
 52 |   To protect each distributor, we want to make it very clear that
 53 | there is no warranty for the free library.  Also, if the library is
 54 | modified by someone else and passed on, the recipients should know
 55 | that what they have is not the original version, so that the original
 56 | author's reputation will not be affected by problems that might be
 57 | introduced by others.
 58 | 
 59 |   Finally, software patents pose a constant threat to the existence of
 60 | any free program.  We wish to make sure that a company cannot
 61 | effectively restrict the users of a free program by obtaining a
 62 | restrictive license from a patent holder.  Therefore, we insist that
 63 | any patent license obtained for a version of the library must be
 64 | consistent with the full freedom of use specified in this license.
 65 | 
 66 |   Most GNU software, including some libraries, is covered by the
 67 | ordinary GNU General Public License.  This license, the GNU Lesser
 68 | General Public License, applies to certain designated libraries, and
 69 | is quite different from the ordinary General Public License.  We use
 70 | this license for certain libraries in order to permit linking those
 71 | libraries into non-free programs.
 72 | 
 73 |   When a program is linked with a library, whether statically or using
 74 | a shared library, the combination of the two is legally speaking a
 75 | combined work, a derivative of the original library.  The ordinary
 76 | General Public License therefore permits such linking only if the
 77 | entire combination fits its criteria of freedom.  The Lesser General
 78 | Public License permits more lax criteria for linking other code with
 79 | the library.
 80 | 
 81 |   We call this license the "Lesser" General Public License because it
 82 | does Less to protect the user's freedom than the ordinary General
 83 | Public License.  It also provides other free software developers Less
 84 | of an advantage over competing non-free programs.  These disadvantages
 85 | are the reason we use the ordinary General Public License for many
 86 | libraries.  However, the Lesser license provides advantages in certain
 87 | special circumstances.
 88 | 
 89 |   For example, on rare occasions, there may be a special need to
 90 | encourage the widest possible use of a certain library, so that it becomes
 91 | a de-facto standard.  To achieve this, non-free programs must be
 92 | allowed to use the library.  A more frequent case is that a free
 93 | library does the same job as widely used non-free libraries.  In this
 94 | case, there is little to gain by limiting the free library to free
 95 | software only, so we use the Lesser General Public License.
 96 | 
 97 |   In other cases, permission to use a particular library in non-free
 98 | programs enables a greater number of people to use a large body of
 99 | free software.  For example, permission to use the GNU C Library in
100 | non-free programs enables many more people to use the whole GNU
101 | operating system, as well as its variant, the GNU/Linux operating
102 | system.
103 | 
104 |   Although the Lesser General Public License is Less protective of the
105 | users' freedom, it does ensure that the user of a program that is
106 | linked with the Library has the freedom and the wherewithal to run
107 | that program using a modified version of the Library.
108 | 
109 |   The precise terms and conditions for copying, distribution and
110 | modification follow.  Pay close attention to the difference between a
111 | "work based on the library" and a "work that uses the library".  The
112 | former contains code derived from the library, whereas the latter must
113 | be combined with the library in order to run.
114 | 
115 |                   GNU LESSER GENERAL PUBLIC LICENSE
116 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
117 | 
118 |   0. This License Agreement applies to any software library or other
119 | program which contains a notice placed by the copyright holder or
120 | other authorized party saying it may be distributed under the terms of
121 | this Lesser General Public License (also called "this License").
122 | Each licensee is addressed as "you".
123 | 
124 |   A "library" means a collection of software functions and/or data
125 | prepared so as to be conveniently linked with application programs
126 | (which use some of those functions and data) to form executables.
127 | 
128 |   The "Library", below, refers to any such software library or work
129 | which has been distributed under these terms.  A "work based on the
130 | Library" means either the Library or any derivative work under
131 | copyright law: that is to say, a work containing the Library or a
132 | portion of it, either verbatim or with modifications and/or translated
133 | straightforwardly into another language.  (Hereinafter, translation is
134 | included without limitation in the term "modification".)
135 | 
136 |   "Source code" for a work means the preferred form of the work for
137 | making modifications to it.  For a library, complete source code means
138 | all the source code for all modules it contains, plus any associated
139 | interface definition files, plus the scripts used to control compilation
140 | and installation of the library.
141 | 
142 |   Activities other than copying, distribution and modification are not
143 | covered by this License; they are outside its scope.  The act of
144 | running a program using the Library is not restricted, and output from
145 | such a program is covered only if its contents constitute a work based
146 | on the Library (independent of the use of the Library in a tool for
147 | writing it).  Whether that is true depends on what the Library does
148 | and what the program that uses the Library does.
149 | 
150 |   1. You may copy and distribute verbatim copies of the Library's
151 | complete source code as you receive it, in any medium, provided that
152 | you conspicuously and appropriately publish on each copy an
153 | appropriate copyright notice and disclaimer of warranty; keep intact
154 | all the notices that refer to this License and to the absence of any
155 | warranty; and distribute a copy of this License along with the
156 | Library.
157 | 
158 |   You may charge a fee for the physical act of transferring a copy,
159 | and you may at your option offer warranty protection in exchange for a
160 | fee.
161 | 
162 |   2. You may modify your copy or copies of the Library or any portion
163 | of it, thus forming a work based on the Library, and copy and
164 | distribute such modifications or work under the terms of Section 1
165 | above, provided that you also meet all of these conditions:
166 | 
167 |     a) The modified work must itself be a software library.
168 | 
169 |     b) You must cause the files modified to carry prominent notices
170 |     stating that you changed the files and the date of any change.
171 | 
172 |     c) You must cause the whole of the work to be licensed at no
173 |     charge to all third parties under the terms of this License.
174 | 
175 |     d) If a facility in the modified Library refers to a function or a
176 |     table of data to be supplied by an application program that uses
177 |     the facility, other than as an argument passed when the facility
178 |     is invoked, then you must make a good faith effort to ensure that,
179 |     in the event an application does not supply such function or
180 |     table, the facility still operates, and performs whatever part of
181 |     its purpose remains meaningful.
182 | 
183 |     (For example, a function in a library to compute square roots has
184 |     a purpose that is entirely well-defined independent of the
185 |     application.  Therefore, Subsection 2d requires that any
186 |     application-supplied function or table used by this function must
187 |     be optional: if the application does not supply it, the square
188 |     root function must still compute square roots.)
189 | 
190 | These requirements apply to the modified work as a whole.  If
191 | identifiable sections of that work are not derived from the Library,
192 | and can be reasonably considered independent and separate works in
193 | themselves, then this License, and its terms, do not apply to those
194 | sections when you distribute them as separate works.  But when you
195 | distribute the same sections as part of a whole which is a work based
196 | on the Library, the distribution of the whole must be on the terms of
197 | this License, whose permissions for other licensees extend to the
198 | entire whole, and thus to each and every part regardless of who wrote
199 | it.
200 | 
201 | Thus, it is not the intent of this section to claim rights or contest
202 | your rights to work written entirely by you; rather, the intent is to
203 | exercise the right to control the distribution of derivative or
204 | collective works based on the Library.
205 | 
206 | In addition, mere aggregation of another work not based on the Library
207 | with the Library (or with a work based on the Library) on a volume of
208 | a storage or distribution medium does not bring the other work under
209 | the scope of this License.
210 | 
211 |   3. You may opt to apply the terms of the ordinary GNU General Public
212 | License instead of this License to a given copy of the Library.  To do
213 | this, you must alter all the notices that refer to this License, so
214 | that they refer to the ordinary GNU General Public License, version 2,
215 | instead of to this License.  (If a newer version than version 2 of the
216 | ordinary GNU General Public License has appeared, then you can specify
217 | that version instead if you wish.)  Do not make any other change in
218 | these notices.
219 | 
220 |   Once this change is made in a given copy, it is irreversible for
221 | that copy, so the ordinary GNU General Public License applies to all
222 | subsequent copies and derivative works made from that copy.
223 | 
224 |   This option is useful when you wish to copy part of the code of
225 | the Library into a program that is not a library.
226 | 
227 |   4. You may copy and distribute the Library (or a portion or
228 | derivative of it, under Section 2) in object code or executable form
229 | under the terms of Sections 1 and 2 above provided that you accompany
230 | it with the complete corresponding machine-readable source code, which
231 | must be distributed under the terms of Sections 1 and 2 above on a
232 | medium customarily used for software interchange.
233 | 
234 |   If distribution of object code is made by offering access to copy
235 | from a designated place, then offering equivalent access to copy the
236 | source code from the same place satisfies the requirement to
237 | distribute the source code, even though third parties are not
238 | compelled to copy the source along with the object code.
239 | 
240 |   5. A program that contains no derivative of any portion of the
241 | Library, but is designed to work with the Library by being compiled or
242 | linked with it, is called a "work that uses the Library".  Such a
243 | work, in isolation, is not a derivative work of the Library, and
244 | therefore falls outside the scope of this License.
245 | 
246 |   However, linking a "work that uses the Library" with the Library
247 | creates an executable that is a derivative of the Library (because it
248 | contains portions of the Library), rather than a "work that uses the
249 | library".  The executable is therefore covered by this License.
250 | Section 6 states terms for distribution of such executables.
251 | 
252 |   When a "work that uses the Library" uses material from a header file
253 | that is part of the Library, the object code for the work may be a
254 | derivative work of the Library even though the source code is not.
255 | Whether this is true is especially significant if the work can be
256 | linked without the Library, or if the work is itself a library.  The
257 | threshold for this to be true is not precisely defined by law.
258 | 
259 |   If such an object file uses only numerical parameters, data
260 | structure layouts and accessors, and small macros and small inline
261 | functions (ten lines or less in length), then the use of the object
262 | file is unrestricted, regardless of whether it is legally a derivative
263 | work.  (Executables containing this object code plus portions of the
264 | Library will still fall under Section 6.)
265 | 
266 |   Otherwise, if the work is a derivative of the Library, you may
267 | distribute the object code for the work under the terms of Section 6.
268 | Any executables containing that work also fall under Section 6,
269 | whether or not they are linked directly with the Library itself.
270 | 
271 |   6. As an exception to the Sections above, you may also combine or
272 | link a "work that uses the Library" with the Library to produce a
273 | work containing portions of the Library, and distribute that work
274 | under terms of your choice, provided that the terms permit
275 | modification of the work for the customer's own use and reverse
276 | engineering for debugging such modifications.
277 | 
278 |   You must give prominent notice with each copy of the work that the
279 | Library is used in it and that the Library and its use are covered by
280 | this License.  You must supply a copy of this License.  If the work
281 | during execution displays copyright notices, you must include the
282 | copyright notice for the Library among them, as well as a reference
283 | directing the user to the copy of this License.  Also, you must do one
284 | of these things:
285 | 
286 |     a) Accompany the work with the complete corresponding
287 |     machine-readable source code for the Library including whatever
288 |     changes were used in the work (which must be distributed under
289 |     Sections 1 and 2 above); and, if the work is an executable linked
290 |     with the Library, with the complete machine-readable "work that
291 |     uses the Library", as object code and/or source code, so that the
292 |     user can modify the Library and then relink to produce a modified
293 |     executable containing the modified Library.  (It is understood
294 |     that the user who changes the contents of definitions files in the
295 |     Library will not necessarily be able to recompile the application
296 |     to use the modified definitions.)
297 | 
298 |     b) Use a suitable shared library mechanism for linking with the
299 |     Library.  A suitable mechanism is one that (1) uses at run time a
300 |     copy of the library already present on the user's computer system,
301 |     rather than copying library functions into the executable, and (2)
302 |     will operate properly with a modified version of the library, if
303 |     the user installs one, as long as the modified version is
304 |     interface-compatible with the version that the work was made with.
305 | 
306 |     c) Accompany the work with a written offer, valid for at
307 |     least three years, to give the same user the materials
308 |     specified in Subsection 6a, above, for a charge no more
309 |     than the cost of performing this distribution.
310 | 
311 |     d) If distribution of the work is made by offering access to copy
312 |     from a designated place, offer equivalent access to copy the above
313 |     specified materials from the same place.
314 | 
315 |     e) Verify that the user has already received a copy of these
316 |     materials or that you have already sent this user a copy.
317 | 
318 |   For an executable, the required form of the "work that uses the
319 | Library" must include any data and utility programs needed for
320 | reproducing the executable from it.  However, as a special exception,
321 | the materials to be distributed need not include anything that is
322 | normally distributed (in either source or binary form) with the major
323 | components (compiler, kernel, and so on) of the operating system on
324 | which the executable runs, unless that component itself accompanies
325 | the executable.
326 | 
327 |   It may happen that this requirement contradicts the license
328 | restrictions of other proprietary libraries that do not normally
329 | accompany the operating system.  Such a contradiction means you cannot
330 | use both them and the Library together in an executable that you
331 | distribute.
332 | 
333 |   7. You may place library facilities that are a work based on the
334 | Library side-by-side in a single library together with other library
335 | facilities not covered by this License, and distribute such a combined
336 | library, provided that the separate distribution of the work based on
337 | the Library and of the other library facilities is otherwise
338 | permitted, and provided that you do these two things:
339 | 
340 |     a) Accompany the combined library with a copy of the same work
341 |     based on the Library, uncombined with any other library
342 |     facilities.  This must be distributed under the terms of the
343 |     Sections above.
344 | 
345 |     b) Give prominent notice with the combined library of the fact
346 |     that part of it is a work based on the Library, and explaining
347 |     where to find the accompanying uncombined form of the same work.
348 | 
349 |   8. You may not copy, modify, sublicense, link with, or distribute
350 | the Library except as expressly provided under this License.  Any
351 | attempt otherwise to copy, modify, sublicense, link with, or
352 | distribute the Library is void, and will automatically terminate your
353 | rights under this License.  However, parties who have received copies,
354 | or rights, from you under this License will not have their licenses
355 | terminated so long as such parties remain in full compliance.
356 | 
357 |   9. You are not required to accept this License, since you have not
358 | signed it.  However, nothing else grants you permission to modify or
359 | distribute the Library or its derivative works.  These actions are
360 | prohibited by law if you do not accept this License.  Therefore, by
361 | modifying or distributing the Library (or any work based on the
362 | Library), you indicate your acceptance of this License to do so, and
363 | all its terms and conditions for copying, distributing or modifying
364 | the Library or works based on it.
365 | 
366 |   10. Each time you redistribute the Library (or any work based on the
367 | Library), the recipient automatically receives a license from the
368 | original licensor to copy, distribute, link with or modify the Library
369 | subject to these terms and conditions.  You may not impose any further
370 | restrictions on the recipients' exercise of the rights granted herein.
371 | You are not responsible for enforcing compliance by third parties with
372 | this License.
373 | 
374 |   11. If, as a consequence of a court judgment or allegation of patent
375 | infringement or for any other reason (not limited to patent issues),
376 | conditions are imposed on you (whether by court order, agreement or
377 | otherwise) that contradict the conditions of this License, they do not
378 | excuse you from the conditions of this License.  If you cannot
379 | distribute so as to satisfy simultaneously your obligations under this
380 | License and any other pertinent obligations, then as a consequence you
381 | may not distribute the Library at all.  For example, if a patent
382 | license would not permit royalty-free redistribution of the Library by
383 | all those who receive copies directly or indirectly through you, then
384 | the only way you could satisfy both it and this License would be to
385 | refrain entirely from distribution of the Library.
386 | 
387 | If any portion of this section is held invalid or unenforceable under any
388 | particular circumstance, the balance of the section is intended to apply,
389 | and the section as a whole is intended to apply in other circumstances.
390 | 
391 | It is not the purpose of this section to induce you to infringe any
392 | patents or other property right claims or to contest validity of any
393 | such claims; this section has the sole purpose of protecting the
394 | integrity of the free software distribution system which is
395 | implemented by public license practices.  Many people have made
396 | generous contributions to the wide range of software distributed
397 | through that system in reliance on consistent application of that
398 | system; it is up to the author/donor to decide if he or she is willing
399 | to distribute software through any other system and a licensee cannot
400 | impose that choice.
401 | 
402 | This section is intended to make thoroughly clear what is believed to
403 | be a consequence of the rest of this License.
404 | 
405 |   12. If the distribution and/or use of the Library is restricted in
406 | certain countries either by patents or by copyrighted interfaces, the
407 | original copyright holder who places the Library under this License may add
408 | an explicit geographical distribution limitation excluding those countries,
409 | so that distribution is permitted only in or among countries not thus
410 | excluded.  In such case, this License incorporates the limitation as if
411 | written in the body of this License.
412 | 
413 |   13. The Free Software Foundation may publish revised and/or new
414 | versions of the Lesser General Public License from time to time.
415 | Such new versions will be similar in spirit to the present version,
416 | but may differ in detail to address new problems or concerns.
417 | 
418 | Each version is given a distinguishing version number.  If the Library
419 | specifies a version number of this License which applies to it and
420 | "any later version", you have the option of following the terms and
421 | conditions either of that version or of any later version published by
422 | the Free Software Foundation.  If the Library does not specify a
423 | license version number, you may choose any version ever published by
424 | the Free Software Foundation.
425 | 
426 |   14. If you wish to incorporate parts of the Library into other free
427 | programs whose distribution conditions are incompatible with these,
428 | write to the author to ask for permission.  For software which is
429 | copyrighted by the Free Software Foundation, write to the Free
430 | Software Foundation; we sometimes make exceptions for this.  Our
431 | decision will be guided by the two goals of preserving the free status
432 | of all derivatives of our free software and of promoting the sharing
433 | and reuse of software generally.
434 | 
435 |                             NO WARRANTY
436 | 
437 |   15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
438 | WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
439 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
440 | OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
441 | KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
442 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
443 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
444 | LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
445 | THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
446 | 
447 |   16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
448 | WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
449 | AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
450 | FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
451 | CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
452 | LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
453 | RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
454 | FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
455 | SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
456 | DAMAGES.
457 | 
458 |                      END OF TERMS AND CONDITIONS
459 | 
460 |            How to Apply These Terms to Your New Libraries
461 | 
462 |   If you develop a new library, and you want it to be of the greatest
463 | possible use to the public, we recommend making it free software that
464 | everyone can redistribute and change.  You can do so by permitting
465 | redistribution under these terms (or, alternatively, under the terms of the
466 | ordinary General Public License).
467 | 
468 |   To apply these terms, attach the following notices to the library.  It is
469 | safest to attach them to the start of each source file to most effectively
470 | convey the exclusion of warranty; and each file should have at least the
471 | "copyright" line and a pointer to where the full notice is found.
472 | 
473 |     <one line to give the library's name and a brief idea of what it does.>
474 |     Copyright (C) <year>  <name of author>
475 | 
476 |     This library is free software; you can redistribute it and/or
477 |     modify it under the terms of the GNU Lesser General Public
478 |     License as published by the Free Software Foundation; either
479 |     version 2.1 of the License, or (at your option) any later version.
480 | 
481 |     This library is distributed in the hope that it will be useful,
482 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
483 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
484 |     Lesser General Public License for more details.
485 | 
486 |     You should have received a copy of the GNU Lesser General Public
487 |     License along with this library; if not, write to the Free Software
488 |     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
489 |     USA
490 | 
491 | Also add information on how to contact you by electronic and paper mail.
492 | 
493 | You should also get your employer (if you work as a programmer) or your
494 | school, if any, to sign a "copyright disclaimer" for the library, if
495 | necessary.  Here is a sample; alter the names:
496 | 
497 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the
498 |   library `Frob' (a library for tweaking knobs) written by James Random
499 |   Hacker.
500 | 
501 |   <signature of Ty Coon>, 1 April 1990
502 |   Ty Coon, President of Vice
503 | 
504 | That's all there is to it!
505 | 


--------------------------------------------------------------------------------
/includes/ImGUI/imgui_impl_opengl3_loader.h:
--------------------------------------------------------------------------------
  1 | //-----------------------------------------------------------------------------
  2 | // About imgui_impl_opengl3_loader.h:
  3 | //
  4 | // We embed our own OpenGL loader to not require user to provide their own or to have to use ours,
  5 | // which proved to be endless problems for users.
  6 | // Our loader is custom-generated, based on gl3w but automatically filtered to only include
  7 | // enums/functions that we use in our imgui_impl_opengl3.cpp source file in order to be small.
  8 | //
  9 | // YOU SHOULD NOT NEED TO INCLUDE/USE THIS DIRECTLY. THIS IS USED BY imgui_impl_opengl3.cpp ONLY.
 10 | // THE REST OF YOUR APP SHOULD USE A DIFFERENT GL LOADER: ANY GL LOADER OF YOUR CHOICE.
 11 | //
 12 | // IF YOU GET BUILD ERRORS IN THIS FILE (commonly macro redefinitions or function redefinitions):
 13 | // IT LIKELY MEANS THAT YOU ARE BUILDING 'imgui_impl_opengl3.cpp' OR INCUDING 'imgui_impl_opengl3_loader.h'
 14 | // IN THE SAME COMPILATION UNIT AS ONE OF YOUR FILE WHICH IS USING A THIRD-PARTY OPENGL LOADER.
 15 | // (e.g. COULD HAPPEN IF YOU ARE DOING A UNITY/JUMBO BUILD, OR INCLUDING .CPP FILES FROM OTHERS)
 16 | // YOU SHOULD NOT BUILD BOTH IN THE SAME COMPILATION UNIT.
 17 | // BUT IF YOU REALLY WANT TO, you can '#define IMGUI_IMPL_OPENGL_LOADER_CUSTOM' and imgui_impl_opengl3.cpp
 18 | // WILL NOT BE USING OUR LOADER, AND INSTEAD EXPECT ANOTHER/YOUR LOADER TO BE AVAILABLE IN THE COMPILATION UNIT.
 19 | //
 20 | // Regenerate with:
 21 | //   python gl3w_gen.py --output ../imgui/backends/imgui_impl_opengl3_loader.h --ref ../imgui/backends/imgui_impl_opengl3.cpp ./extra_symbols.txt
 22 | //
 23 | // More info:
 24 | //   https://github.com/dearimgui/gl3w_stripped
 25 | //   https://github.com/ocornut/imgui/issues/4445
 26 | //-----------------------------------------------------------------------------
 27 | 
 28 | /*
 29 |  * This file was generated with gl3w_gen.py, part of imgl3w
 30 |  * (hosted at https://github.com/dearimgui/gl3w_stripped)
 31 |  *
 32 |  * This is free and unencumbered software released into the public domain.
 33 |  *
 34 |  * Anyone is free to copy, modify, publish, use, compile, sell, or
 35 |  * distribute this software, either in source code form or as a compiled
 36 |  * binary, for any purpose, commercial or non-commercial, and by any
 37 |  * means.
 38 |  *
 39 |  * In jurisdictions that recognize copyright laws, the author or authors
 40 |  * of this software dedicate any and all copyright interest in the
 41 |  * software to the public domain. We make this dedication for the benefit
 42 |  * of the public at large and to the detriment of our heirs and
 43 |  * successors. We intend this dedication to be an overt act of
 44 |  * relinquishment in perpetuity of all present and future rights to this
 45 |  * software under copyright law.
 46 |  *
 47 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 48 |  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 49 |  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 50 |  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 51 |  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 52 |  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 53 |  * OTHER DEALINGS IN THE SOFTWARE.
 54 |  */
 55 | 
 56 | #ifndef IMGUI_IMPL_OPENGL3_LOADER_H
 57 | #define IMGUI_IMPL_OPENGL3_LOADER_H
 58 | 
 59 | #ifndef __gl3w_h_
 60 | #define __gl3w_h_
 61 | 
 62 | // Adapted from KHR/khrplatform.h to avoid including entire file.
 63 | #ifndef __khrplatform_h_
 64 | typedef          float         khronos_float_t;
 65 | typedef signed   char          khronos_int8_t;
 66 | typedef unsigned char          khronos_uint8_t;
 67 | typedef signed   short int     khronos_int16_t;
 68 | typedef unsigned short int     khronos_uint16_t;
 69 | #ifdef _WIN64
 70 | typedef signed   long long int khronos_intptr_t;
 71 | typedef signed   long long int khronos_ssize_t;
 72 | #else
 73 | typedef signed   long  int     khronos_intptr_t;
 74 | typedef signed   long  int     khronos_ssize_t;
 75 | #endif
 76 | 
 77 | #if defined(_MSC_VER) && !defined(__clang__)
 78 | typedef signed   __int64       khronos_int64_t;
 79 | typedef unsigned __int64       khronos_uint64_t;
 80 | #elif (defined(__clang__) || defined(__GNUC__)) && (__cplusplus < 201100)
 81 | #include <stdint.h>
 82 | typedef          int64_t       khronos_int64_t;
 83 | typedef          uint64_t      khronos_uint64_t;
 84 | #else
 85 | typedef signed   long long     khronos_int64_t;
 86 | typedef unsigned long long     khronos_uint64_t;
 87 | #endif
 88 | #endif  // __khrplatform_h_
 89 | 
 90 | #ifndef __gl_glcorearb_h_
 91 | #define __gl_glcorearb_h_ 1
 92 | #ifdef __cplusplus
 93 | extern "C" {
 94 | #endif
 95 | /*
 96 | ** Copyright 2013-2020 The Khronos Group Inc.
 97 | ** SPDX-License-Identifier: MIT
 98 | **
 99 | ** This header is generated from the Khronos OpenGL / OpenGL ES XML
100 | ** API Registry. The current version of the Registry, generator scripts
101 | ** used to make the header, and the header can be found at
102 | **   https://github.com/KhronosGroup/OpenGL-Registry
103 | */
104 | #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__)
105 | #ifndef WIN32_LEAN_AND_MEAN
106 | #define WIN32_LEAN_AND_MEAN 1
107 | #endif
108 | #include <windows.h>
109 | #endif
110 | #ifndef APIENTRY
111 | #define APIENTRY
112 | #endif
113 | #ifndef APIENTRYP
114 | #define APIENTRYP APIENTRY *
115 | #endif
116 | #ifndef GLAPI
117 | #define GLAPI extern
118 | #endif
119 | /* glcorearb.h is for use with OpenGL core profile implementations.
120 | ** It should should be placed in the same directory as gl.h and
121 | ** included as <GL/glcorearb.h>.
122 | **
123 | ** glcorearb.h includes only APIs in the latest OpenGL core profile
124 | ** implementation together with APIs in newer ARB extensions which 
125 | ** can be supported by the core profile. It does not, and never will
126 | ** include functionality removed from the core profile, such as
127 | ** fixed-function vertex and fragment processing.
128 | **
129 | ** Do not #include both <GL/glcorearb.h> and either of <GL/gl.h> or
130 | ** <GL/glext.h> in the same source file.
131 | */
132 | /* Generated C header for:
133 |  * API: gl
134 |  * Profile: core
135 |  * Versions considered: .*
136 |  * Versions emitted: .*
137 |  * Default extensions included: glcore
138 |  * Additional extensions included: _nomatch_^
139 |  * Extensions removed: _nomatch_^
140 |  */
141 | #ifndef GL_VERSION_1_0
142 | typedef void GLvoid;
143 | typedef unsigned int GLenum;
144 | 
145 | typedef khronos_float_t GLfloat;
146 | typedef int GLint;
147 | typedef int GLsizei;
148 | typedef unsigned int GLbitfield;
149 | typedef double GLdouble;
150 | typedef unsigned int GLuint;
151 | typedef unsigned char GLboolean;
152 | typedef khronos_uint8_t GLubyte;
153 | #define GL_COLOR_BUFFER_BIT               0x00004000
154 | #define GL_FALSE                          0
155 | #define GL_TRUE                           1
156 | #define GL_TRIANGLES                      0x0004
157 | #define GL_ONE                            1
158 | #define GL_SRC_ALPHA                      0x0302
159 | #define GL_ONE_MINUS_SRC_ALPHA            0x0303
160 | #define GL_FRONT                          0x0404
161 | #define GL_BACK                           0x0405
162 | #define GL_FRONT_AND_BACK                 0x0408
163 | #define GL_POLYGON_MODE                   0x0B40
164 | #define GL_CULL_FACE                      0x0B44
165 | #define GL_DEPTH_TEST                     0x0B71
166 | #define GL_STENCIL_TEST                   0x0B90
167 | #define GL_VIEWPORT                       0x0BA2
168 | #define GL_BLEND                          0x0BE2
169 | #define GL_SCISSOR_BOX                    0x0C10
170 | #define GL_SCISSOR_TEST                   0x0C11
171 | #define GL_UNPACK_ROW_LENGTH              0x0CF2
172 | #define GL_PACK_ALIGNMENT                 0x0D05
173 | #define GL_TEXTURE_2D                     0x0DE1
174 | #define GL_UNSIGNED_BYTE                  0x1401
175 | #define GL_UNSIGNED_SHORT                 0x1403
176 | #define GL_UNSIGNED_INT                   0x1405
177 | #define GL_FLOAT                          0x1406
178 | #define GL_RGBA                           0x1908
179 | #define GL_FILL                           0x1B02
180 | #define GL_VENDOR                         0x1F00
181 | #define GL_RENDERER                       0x1F01
182 | #define GL_VERSION                        0x1F02
183 | #define GL_EXTENSIONS                     0x1F03
184 | #define GL_LINEAR                         0x2601
185 | #define GL_TEXTURE_MAG_FILTER             0x2800
186 | #define GL_TEXTURE_MIN_FILTER             0x2801
187 | typedef void (APIENTRYP PFNGLPOLYGONMODEPROC) (GLenum face, GLenum mode);
188 | typedef void (APIENTRYP PFNGLSCISSORPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
189 | typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC) (GLenum target, GLenum pname, GLint param);
190 | typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
191 | typedef void (APIENTRYP PFNGLCLEARPROC) (GLbitfield mask);
192 | typedef void (APIENTRYP PFNGLCLEARCOLORPROC) (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
193 | typedef void (APIENTRYP PFNGLDISABLEPROC) (GLenum cap);
194 | typedef void (APIENTRYP PFNGLENABLEPROC) (GLenum cap);
195 | typedef void (APIENTRYP PFNGLFLUSHPROC) (void);
196 | typedef void (APIENTRYP PFNGLPIXELSTOREIPROC) (GLenum pname, GLint param);
197 | typedef void (APIENTRYP PFNGLREADPIXELSPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
198 | typedef GLenum (APIENTRYP PFNGLGETERRORPROC) (void);
199 | typedef void (APIENTRYP PFNGLGETINTEGERVPROC) (GLenum pname, GLint *data);
200 | typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGPROC) (GLenum name);
201 | typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC) (GLenum cap);
202 | typedef void (APIENTRYP PFNGLVIEWPORTPROC) (GLint x, GLint y, GLsizei width, GLsizei height);
203 | #ifdef GL_GLEXT_PROTOTYPES
204 | GLAPI void APIENTRY glPolygonMode (GLenum face, GLenum mode);
205 | GLAPI void APIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height);
206 | GLAPI void APIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param);
207 | GLAPI void APIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels);
208 | GLAPI void APIENTRY glClear (GLbitfield mask);
209 | GLAPI void APIENTRY glClearColor (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
210 | GLAPI void APIENTRY glDisable (GLenum cap);
211 | GLAPI void APIENTRY glEnable (GLenum cap);
212 | GLAPI void APIENTRY glFlush (void);
213 | GLAPI void APIENTRY glPixelStorei (GLenum pname, GLint param);
214 | GLAPI void APIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels);
215 | GLAPI GLenum APIENTRY glGetError (void);
216 | GLAPI void APIENTRY glGetIntegerv (GLenum pname, GLint *data);
217 | GLAPI const GLubyte *APIENTRY glGetString (GLenum name);
218 | GLAPI GLboolean APIENTRY glIsEnabled (GLenum cap);
219 | GLAPI void APIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height);
220 | #endif
221 | #endif /* GL_VERSION_1_0 */
222 | #ifndef GL_VERSION_1_1
223 | typedef khronos_float_t GLclampf;
224 | typedef double GLclampd;
225 | #define GL_TEXTURE_BINDING_2D             0x8069
226 | typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices);
227 | typedef void (APIENTRYP PFNGLBINDTEXTUREPROC) (GLenum target, GLuint texture);
228 | typedef void (APIENTRYP PFNGLDELETETEXTURESPROC) (GLsizei n, const GLuint *textures);
229 | typedef void (APIENTRYP PFNGLGENTEXTURESPROC) (GLsizei n, GLuint *textures);
230 | #ifdef GL_GLEXT_PROTOTYPES
231 | GLAPI void APIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const void *indices);
232 | GLAPI void APIENTRY glBindTexture (GLenum target, GLuint texture);
233 | GLAPI void APIENTRY glDeleteTextures (GLsizei n, const GLuint *textures);
234 | GLAPI void APIENTRY glGenTextures (GLsizei n, GLuint *textures);
235 | #endif
236 | #endif /* GL_VERSION_1_1 */
237 | #ifndef GL_VERSION_1_3
238 | #define GL_TEXTURE0                       0x84C0
239 | #define GL_ACTIVE_TEXTURE                 0x84E0
240 | typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
241 | #ifdef GL_GLEXT_PROTOTYPES
242 | GLAPI void APIENTRY glActiveTexture (GLenum texture);
243 | #endif
244 | #endif /* GL_VERSION_1_3 */
245 | #ifndef GL_VERSION_1_4
246 | #define GL_BLEND_DST_RGB                  0x80C8
247 | #define GL_BLEND_SRC_RGB                  0x80C9
248 | #define GL_BLEND_DST_ALPHA                0x80CA
249 | #define GL_BLEND_SRC_ALPHA                0x80CB
250 | #define GL_FUNC_ADD                       0x8006
251 | typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
252 | typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode);
253 | #ifdef GL_GLEXT_PROTOTYPES
254 | GLAPI void APIENTRY glBlendFuncSeparate (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
255 | GLAPI void APIENTRY glBlendEquation (GLenum mode);
256 | #endif
257 | #endif /* GL_VERSION_1_4 */
258 | #ifndef GL_VERSION_1_5
259 | typedef khronos_ssize_t GLsizeiptr;
260 | typedef khronos_intptr_t GLintptr;
261 | #define GL_ARRAY_BUFFER                   0x8892
262 | #define GL_ELEMENT_ARRAY_BUFFER           0x8893
263 | #define GL_ARRAY_BUFFER_BINDING           0x8894
264 | #define GL_ELEMENT_ARRAY_BUFFER_BINDING   0x8895
265 | #define GL_STREAM_DRAW                    0x88E0
266 | typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
267 | typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
268 | typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
269 | typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const void *data, GLenum usage);
270 | typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
271 | #ifdef GL_GLEXT_PROTOTYPES
272 | GLAPI void APIENTRY glBindBuffer (GLenum target, GLuint buffer);
273 | GLAPI void APIENTRY glDeleteBuffers (GLsizei n, const GLuint *buffers);
274 | GLAPI void APIENTRY glGenBuffers (GLsizei n, GLuint *buffers);
275 | GLAPI void APIENTRY glBufferData (GLenum target, GLsizeiptr size, const void *data, GLenum usage);
276 | GLAPI void APIENTRY glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const void *data);
277 | #endif
278 | #endif /* GL_VERSION_1_5 */
279 | #ifndef GL_VERSION_2_0
280 | typedef char GLchar;
281 | typedef khronos_int16_t GLshort;
282 | typedef khronos_int8_t GLbyte;
283 | typedef khronos_uint16_t GLushort;
284 | #define GL_BLEND_EQUATION_RGB             0x8009
285 | #define GL_VERTEX_ATTRIB_ARRAY_ENABLED    0x8622
286 | #define GL_VERTEX_ATTRIB_ARRAY_SIZE       0x8623
287 | #define GL_VERTEX_ATTRIB_ARRAY_STRIDE     0x8624
288 | #define GL_VERTEX_ATTRIB_ARRAY_TYPE       0x8625
289 | #define GL_VERTEX_ATTRIB_ARRAY_POINTER    0x8645
290 | #define GL_BLEND_EQUATION_ALPHA           0x883D
291 | #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A
292 | #define GL_FRAGMENT_SHADER                0x8B30
293 | #define GL_VERTEX_SHADER                  0x8B31
294 | #define GL_COMPILE_STATUS                 0x8B81
295 | #define GL_LINK_STATUS                    0x8B82
296 | #define GL_INFO_LOG_LENGTH                0x8B84
297 | #define GL_CURRENT_PROGRAM                0x8B8D
298 | #define GL_UPPER_LEFT                     0x8CA2
299 | typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha);
300 | typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
301 | typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader);
302 | typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void);
303 | typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type);
304 | typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program);
305 | typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader);
306 | typedef void (APIENTRYP PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader);
307 | typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index);
308 | typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index);
309 | typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name);
310 | typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
311 | typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
312 | typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
313 | typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
314 | typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name);
315 | typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint *params);
316 | typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, void **pointer);
317 | typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC) (GLuint program);
318 | typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program);
319 | typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
320 | typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program);
321 | typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
322 | typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
323 | typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
324 | #ifdef GL_GLEXT_PROTOTYPES
325 | GLAPI void APIENTRY glBlendEquationSeparate (GLenum modeRGB, GLenum modeAlpha);
326 | GLAPI void APIENTRY glAttachShader (GLuint program, GLuint shader);
327 | GLAPI void APIENTRY glCompileShader (GLuint shader);
328 | GLAPI GLuint APIENTRY glCreateProgram (void);
329 | GLAPI GLuint APIENTRY glCreateShader (GLenum type);
330 | GLAPI void APIENTRY glDeleteProgram (GLuint program);
331 | GLAPI void APIENTRY glDeleteShader (GLuint shader);
332 | GLAPI void APIENTRY glDetachShader (GLuint program, GLuint shader);
333 | GLAPI void APIENTRY glDisableVertexAttribArray (GLuint index);
334 | GLAPI void APIENTRY glEnableVertexAttribArray (GLuint index);
335 | GLAPI GLint APIENTRY glGetAttribLocation (GLuint program, const GLchar *name);
336 | GLAPI void APIENTRY glGetProgramiv (GLuint program, GLenum pname, GLint *params);
337 | GLAPI void APIENTRY glGetProgramInfoLog (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
338 | GLAPI void APIENTRY glGetShaderiv (GLuint shader, GLenum pname, GLint *params);
339 | GLAPI void APIENTRY glGetShaderInfoLog (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
340 | GLAPI GLint APIENTRY glGetUniformLocation (GLuint program, const GLchar *name);
341 | GLAPI void APIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint *params);
342 | GLAPI void APIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, void **pointer);
343 | GLAPI GLboolean APIENTRY glIsProgram (GLuint program);
344 | GLAPI void APIENTRY glLinkProgram (GLuint program);
345 | GLAPI void APIENTRY glShaderSource (GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length);
346 | GLAPI void APIENTRY glUseProgram (GLuint program);
347 | GLAPI void APIENTRY glUniform1i (GLint location, GLint v0);
348 | GLAPI void APIENTRY glUniformMatrix4fv (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
349 | GLAPI void APIENTRY glVertexAttribPointer (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer);
350 | #endif
351 | #endif /* GL_VERSION_2_0 */
352 | #ifndef GL_VERSION_3_0
353 | typedef khronos_uint16_t GLhalf;
354 | #define GL_MAJOR_VERSION                  0x821B
355 | #define GL_MINOR_VERSION                  0x821C
356 | #define GL_NUM_EXTENSIONS                 0x821D
357 | #define GL_FRAMEBUFFER_SRGB               0x8DB9
358 | #define GL_VERTEX_ARRAY_BINDING           0x85B5
359 | typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC) (GLenum target, GLuint index, GLboolean *data);
360 | typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC) (GLenum target, GLuint index, GLint *data);
361 | typedef const GLubyte *(APIENTRYP PFNGLGETSTRINGIPROC) (GLenum name, GLuint index);
362 | typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC) (GLuint array);
363 | typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint *arrays);
364 | typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint *arrays);
365 | #ifdef GL_GLEXT_PROTOTYPES
366 | GLAPI const GLubyte *APIENTRY glGetStringi (GLenum name, GLuint index);
367 | GLAPI void APIENTRY glBindVertexArray (GLuint array);
368 | GLAPI void APIENTRY glDeleteVertexArrays (GLsizei n, const GLuint *arrays);
369 | GLAPI void APIENTRY glGenVertexArrays (GLsizei n, GLuint *arrays);
370 | #endif
371 | #endif /* GL_VERSION_3_0 */
372 | #ifndef GL_VERSION_3_1
373 | #define GL_VERSION_3_1 1
374 | #define GL_PRIMITIVE_RESTART              0x8F9D
375 | #endif /* GL_VERSION_3_1 */
376 | #ifndef GL_VERSION_3_2
377 | #define GL_VERSION_3_2 1
378 | typedef struct __GLsync *GLsync;
379 | typedef khronos_uint64_t GLuint64;
380 | typedef khronos_int64_t GLint64;
381 | #define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002
382 | #define GL_CONTEXT_PROFILE_MASK           0x9126
383 | typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
384 | typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC) (GLenum target, GLuint index, GLint64 *data);
385 | #ifdef GL_GLEXT_PROTOTYPES
386 | GLAPI void APIENTRY glDrawElementsBaseVertex (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex);
387 | #endif
388 | #endif /* GL_VERSION_3_2 */
389 | #ifndef GL_VERSION_3_3
390 | #define GL_VERSION_3_3 1
391 | #define GL_SAMPLER_BINDING                0x8919
392 | typedef void (APIENTRYP PFNGLBINDSAMPLERPROC) (GLuint unit, GLuint sampler);
393 | #ifdef GL_GLEXT_PROTOTYPES
394 | GLAPI void APIENTRY glBindSampler (GLuint unit, GLuint sampler);
395 | #endif
396 | #endif /* GL_VERSION_3_3 */
397 | #ifndef GL_VERSION_4_1
398 | typedef void (APIENTRYP PFNGLGETFLOATI_VPROC) (GLenum target, GLuint index, GLfloat *data);
399 | typedef void (APIENTRYP PFNGLGETDOUBLEI_VPROC) (GLenum target, GLuint index, GLdouble *data);
400 | #endif /* GL_VERSION_4_1 */
401 | #ifndef GL_VERSION_4_3
402 | typedef void (APIENTRY  *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
403 | #endif /* GL_VERSION_4_3 */
404 | #ifndef GL_VERSION_4_5
405 | #define GL_CLIP_ORIGIN                    0x935C
406 | typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKI_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint *param);
407 | typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKI64_VPROC) (GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
408 | #endif /* GL_VERSION_4_5 */
409 | #ifndef GL_ARB_bindless_texture
410 | typedef khronos_uint64_t GLuint64EXT;
411 | #endif /* GL_ARB_bindless_texture */
412 | #ifndef GL_ARB_cl_event
413 | struct _cl_context;
414 | struct _cl_event;
415 | #endif /* GL_ARB_cl_event */
416 | #ifndef GL_ARB_clip_control
417 | #define GL_ARB_clip_control 1
418 | #endif /* GL_ARB_clip_control */
419 | #ifndef GL_ARB_debug_output
420 | typedef void (APIENTRY  *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);
421 | #endif /* GL_ARB_debug_output */
422 | #ifndef GL_EXT_EGL_image_storage
423 | typedef void *GLeglImageOES;
424 | #endif /* GL_EXT_EGL_image_storage */
425 | #ifndef GL_EXT_direct_state_access
426 | typedef void (APIENTRYP PFNGLGETFLOATI_VEXTPROC) (GLenum pname, GLuint index, GLfloat *params);
427 | typedef void (APIENTRYP PFNGLGETDOUBLEI_VEXTPROC) (GLenum pname, GLuint index, GLdouble *params);
428 | typedef void (APIENTRYP PFNGLGETPOINTERI_VEXTPROC) (GLenum pname, GLuint index, void **params);
429 | typedef void (APIENTRYP PFNGLGETVERTEXARRAYINTEGERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, GLint *param);
430 | typedef void (APIENTRYP PFNGLGETVERTEXARRAYPOINTERI_VEXTPROC) (GLuint vaobj, GLuint index, GLenum pname, void **param);
431 | #endif /* GL_EXT_direct_state_access */
432 | #ifndef GL_NV_draw_vulkan_image
433 | typedef void (APIENTRY  *GLVULKANPROCNV)(void);
434 | #endif /* GL_NV_draw_vulkan_image */
435 | #ifndef GL_NV_gpu_shader5
436 | typedef khronos_int64_t GLint64EXT;
437 | #endif /* GL_NV_gpu_shader5 */
438 | #ifndef GL_NV_vertex_buffer_unified_memory
439 | typedef void (APIENTRYP PFNGLGETINTEGERUI64I_VNVPROC) (GLenum value, GLuint index, GLuint64EXT *result);
440 | #endif /* GL_NV_vertex_buffer_unified_memory */
441 | #ifdef __cplusplus
442 | }
443 | #endif
444 | #endif
445 | 
446 | #ifndef GL3W_API
447 | #define GL3W_API
448 | #endif
449 | 
450 | #ifndef __gl_h_
451 | #define __gl_h_
452 | #endif
453 | 
454 | #ifdef __cplusplus
455 | extern "C" {
456 | #endif
457 | 
458 | #define GL3W_OK 0
459 | #define GL3W_ERROR_INIT -1
460 | #define GL3W_ERROR_LIBRARY_OPEN -2
461 | #define GL3W_ERROR_OPENGL_VERSION -3
462 | 
463 | typedef void (*GL3WglProc)(void);
464 | typedef GL3WglProc (*GL3WGetProcAddressProc)(const char *proc);
465 | 
466 | /* gl3w api */
467 | GL3W_API int imgl3wInit(void);
468 | GL3W_API int imgl3wInit2(GL3WGetProcAddressProc proc);
469 | GL3W_API int imgl3wIsSupported(int major, int minor);
470 | GL3W_API GL3WglProc imgl3wGetProcAddress(const char *proc);
471 | 
472 | /* gl3w internal state */
473 | union ImGL3WProcs {
474 |     GL3WglProc ptr[59];
475 |     struct {
476 |         PFNGLACTIVETEXTUREPROC            ActiveTexture;
477 |         PFNGLATTACHSHADERPROC             AttachShader;
478 |         PFNGLBINDBUFFERPROC               BindBuffer;
479 |         PFNGLBINDSAMPLERPROC              BindSampler;
480 |         PFNGLBINDTEXTUREPROC              BindTexture;
481 |         PFNGLBINDVERTEXARRAYPROC          BindVertexArray;
482 |         PFNGLBLENDEQUATIONPROC            BlendEquation;
483 |         PFNGLBLENDEQUATIONSEPARATEPROC    BlendEquationSeparate;
484 |         PFNGLBLENDFUNCSEPARATEPROC        BlendFuncSeparate;
485 |         PFNGLBUFFERDATAPROC               BufferData;
486 |         PFNGLBUFFERSUBDATAPROC            BufferSubData;
487 |         PFNGLCLEARPROC                    Clear;
488 |         PFNGLCLEARCOLORPROC               ClearColor;
489 |         PFNGLCOMPILESHADERPROC            CompileShader;
490 |         PFNGLCREATEPROGRAMPROC            CreateProgram;
491 |         PFNGLCREATESHADERPROC             CreateShader;
492 |         PFNGLDELETEBUFFERSPROC            DeleteBuffers;
493 |         PFNGLDELETEPROGRAMPROC            DeleteProgram;
494 |         PFNGLDELETESHADERPROC             DeleteShader;
495 |         PFNGLDELETETEXTURESPROC           DeleteTextures;
496 |         PFNGLDELETEVERTEXARRAYSPROC       DeleteVertexArrays;
497 |         PFNGLDETACHSHADERPROC             DetachShader;
498 |         PFNGLDISABLEPROC                  Disable;
499 |         PFNGLDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray;
500 |         PFNGLDRAWELEMENTSPROC             DrawElements;
501 |         PFNGLDRAWELEMENTSBASEVERTEXPROC   DrawElementsBaseVertex;
502 |         PFNGLENABLEPROC                   Enable;
503 |         PFNGLENABLEVERTEXATTRIBARRAYPROC  EnableVertexAttribArray;
504 |         PFNGLFLUSHPROC                    Flush;
505 |         PFNGLGENBUFFERSPROC               GenBuffers;
506 |         PFNGLGENTEXTURESPROC              GenTextures;
507 |         PFNGLGENVERTEXARRAYSPROC          GenVertexArrays;
508 |         PFNGLGETATTRIBLOCATIONPROC        GetAttribLocation;
509 |         PFNGLGETERRORPROC                 GetError;
510 |         PFNGLGETINTEGERVPROC              GetIntegerv;
511 |         PFNGLGETPROGRAMINFOLOGPROC        GetProgramInfoLog;
512 |         PFNGLGETPROGRAMIVPROC             GetProgramiv;
513 |         PFNGLGETSHADERINFOLOGPROC         GetShaderInfoLog;
514 |         PFNGLGETSHADERIVPROC              GetShaderiv;
515 |         PFNGLGETSTRINGPROC                GetString;
516 |         PFNGLGETSTRINGIPROC               GetStringi;
517 |         PFNGLGETUNIFORMLOCATIONPROC       GetUniformLocation;
518 |         PFNGLGETVERTEXATTRIBPOINTERVPROC  GetVertexAttribPointerv;
519 |         PFNGLGETVERTEXATTRIBIVPROC        GetVertexAttribiv;
520 |         PFNGLISENABLEDPROC                IsEnabled;
521 |         PFNGLISPROGRAMPROC                IsProgram;
522 |         PFNGLLINKPROGRAMPROC              LinkProgram;
523 |         PFNGLPIXELSTOREIPROC              PixelStorei;
524 |         PFNGLPOLYGONMODEPROC              PolygonMode;
525 |         PFNGLREADPIXELSPROC               ReadPixels;
526 |         PFNGLSCISSORPROC                  Scissor;
527 |         PFNGLSHADERSOURCEPROC             ShaderSource;
528 |         PFNGLTEXIMAGE2DPROC               TexImage2D;
529 |         PFNGLTEXPARAMETERIPROC            TexParameteri;
530 |         PFNGLUNIFORM1IPROC                Uniform1i;
531 |         PFNGLUNIFORMMATRIX4FVPROC         UniformMatrix4fv;
532 |         PFNGLUSEPROGRAMPROC               UseProgram;
533 |         PFNGLVERTEXATTRIBPOINTERPROC      VertexAttribPointer;
534 |         PFNGLVIEWPORTPROC                 Viewport;
535 |     } gl;
536 | };
537 | 
538 | GL3W_API extern union ImGL3WProcs imgl3wProcs;
539 | 
540 | /* OpenGL functions */
541 | #define glActiveTexture                   imgl3wProcs.gl.ActiveTexture
542 | #define glAttachShader                    imgl3wProcs.gl.AttachShader
543 | #define glBindBuffer                      imgl3wProcs.gl.BindBuffer
544 | #define glBindSampler                     imgl3wProcs.gl.BindSampler
545 | #define glBindTexture                     imgl3wProcs.gl.BindTexture
546 | #define glBindVertexArray                 imgl3wProcs.gl.BindVertexArray
547 | #define glBlendEquation                   imgl3wProcs.gl.BlendEquation
548 | #define glBlendEquationSeparate           imgl3wProcs.gl.BlendEquationSeparate
549 | #define glBlendFuncSeparate               imgl3wProcs.gl.BlendFuncSeparate
550 | #define glBufferData                      imgl3wProcs.gl.BufferData
551 | #define glBufferSubData                   imgl3wProcs.gl.BufferSubData
552 | #define glClear                           imgl3wProcs.gl.Clear
553 | #define glClearColor                      imgl3wProcs.gl.ClearColor
554 | #define glCompileShader                   imgl3wProcs.gl.CompileShader
555 | #define glCreateProgram                   imgl3wProcs.gl.CreateProgram
556 | #define glCreateShader                    imgl3wProcs.gl.CreateShader
557 | #define glDeleteBuffers                   imgl3wProcs.gl.DeleteBuffers
558 | #define glDeleteProgram                   imgl3wProcs.gl.DeleteProgram
559 | #define glDeleteShader                    imgl3wProcs.gl.DeleteShader
560 | #define glDeleteTextures                  imgl3wProcs.gl.DeleteTextures
561 | #define glDeleteVertexArrays              imgl3wProcs.gl.DeleteVertexArrays
562 | #define glDetachShader                    imgl3wProcs.gl.DetachShader
563 | #define glDisable                         imgl3wProcs.gl.Disable
564 | #define glDisableVertexAttribArray        imgl3wProcs.gl.DisableVertexAttribArray
565 | #define glDrawElements                    imgl3wProcs.gl.DrawElements
566 | #define glDrawElementsBaseVertex          imgl3wProcs.gl.DrawElementsBaseVertex
567 | #define glEnable                          imgl3wProcs.gl.Enable
568 | #define glEnableVertexAttribArray         imgl3wProcs.gl.EnableVertexAttribArray
569 | #define glFlush                           imgl3wProcs.gl.Flush
570 | #define glGenBuffers                      imgl3wProcs.gl.GenBuffers
571 | #define glGenTextures                     imgl3wProcs.gl.GenTextures
572 | #define glGenVertexArrays                 imgl3wProcs.gl.GenVertexArrays
573 | #define glGetAttribLocation               imgl3wProcs.gl.GetAttribLocation
574 | #define glGetError                        imgl3wProcs.gl.GetError
575 | #define glGetIntegerv                     imgl3wProcs.gl.GetIntegerv
576 | #define glGetProgramInfoLog               imgl3wProcs.gl.GetProgramInfoLog
577 | #define glGetProgramiv                    imgl3wProcs.gl.GetProgramiv
578 | #define glGetShaderInfoLog                imgl3wProcs.gl.GetShaderInfoLog
579 | #define glGetShaderiv                     imgl3wProcs.gl.GetShaderiv
580 | #define glGetString                       imgl3wProcs.gl.GetString
581 | #define glGetStringi                      imgl3wProcs.gl.GetStringi
582 | #define glGetUniformLocation              imgl3wProcs.gl.GetUniformLocation
583 | #define glGetVertexAttribPointerv         imgl3wProcs.gl.GetVertexAttribPointerv
584 | #define glGetVertexAttribiv               imgl3wProcs.gl.GetVertexAttribiv
585 | #define glIsEnabled                       imgl3wProcs.gl.IsEnabled
586 | #define glIsProgram                       imgl3wProcs.gl.IsProgram
587 | #define glLinkProgram                     imgl3wProcs.gl.LinkProgram
588 | #define glPixelStorei                     imgl3wProcs.gl.PixelStorei
589 | #define glPolygonMode                     imgl3wProcs.gl.PolygonMode
590 | #define glReadPixels                      imgl3wProcs.gl.ReadPixels
591 | #define glScissor                         imgl3wProcs.gl.Scissor
592 | #define glShaderSource                    imgl3wProcs.gl.ShaderSource
593 | #define glTexImage2D                      imgl3wProcs.gl.TexImage2D
594 | #define glTexParameteri                   imgl3wProcs.gl.TexParameteri
595 | #define glUniform1i                       imgl3wProcs.gl.Uniform1i
596 | #define glUniformMatrix4fv                imgl3wProcs.gl.UniformMatrix4fv
597 | #define glUseProgram                      imgl3wProcs.gl.UseProgram
598 | #define glVertexAttribPointer             imgl3wProcs.gl.VertexAttribPointer
599 | #define glViewport                        imgl3wProcs.gl.Viewport
600 | 
601 | #ifdef __cplusplus
602 | }
603 | #endif
604 | 
605 | #endif
606 | 
607 | #ifdef IMGL3W_IMPL
608 | #ifdef __cplusplus
609 | extern "C" {
610 | #endif
611 | 
612 | #include <stdlib.h>
613 | 
614 | #define ARRAY_SIZE(x)  (sizeof(x) / sizeof((x)[0]))
615 | 
616 | #if defined(_WIN32)
617 | #ifndef WIN32_LEAN_AND_MEAN
618 | #define WIN32_LEAN_AND_MEAN 1
619 | #endif
620 | #include <windows.h>
621 | 
622 | static HMODULE libgl;
623 | typedef PROC(__stdcall* GL3WglGetProcAddr)(LPCSTR);
624 | static GL3WglGetProcAddr wgl_get_proc_address;
625 | 
626 | static int open_libgl(void)
627 | {
628 |     libgl = LoadLibraryA("opengl32.dll");
629 |     if (!libgl)
630 |         return GL3W_ERROR_LIBRARY_OPEN;
631 |     wgl_get_proc_address = (GL3WglGetProcAddr)GetProcAddress(libgl, "wglGetProcAddress");
632 |     return GL3W_OK;
633 | }
634 | 
635 | static void close_libgl(void) { FreeLibrary(libgl); }
636 | static GL3WglProc get_proc(const char *proc)
637 | {
638 |     GL3WglProc res;
639 |     res = (GL3WglProc)wgl_get_proc_address(proc);
640 |     if (!res)
641 |         res = (GL3WglProc)GetProcAddress(libgl, proc);
642 |     return res;
643 | }
644 | #elif defined(__APPLE__)
645 | #include <dlfcn.h>
646 | 
647 | static void *libgl;
648 | static int open_libgl(void)
649 | {
650 |     libgl = dlopen("/System/Library/Frameworks/OpenGL.framework/OpenGL", RTLD_LAZY | RTLD_LOCAL);
651 |     if (!libgl)
652 |         return GL3W_ERROR_LIBRARY_OPEN;
653 |     return GL3W_OK;
654 | }
655 | 
656 | static void close_libgl(void) { dlclose(libgl); }
657 | 
658 | static GL3WglProc get_proc(const char *proc)
659 | {
660 |     GL3WglProc res;
661 |     *(void **)(&res) = dlsym(libgl, proc);
662 |     return res;
663 | }
664 | #else
665 | #include <dlfcn.h>
666 | 
667 | static void *libgl;
668 | static GL3WglProc (*glx_get_proc_address)(const GLubyte *);
669 | 
670 | static int open_libgl(void)
671 | {
672 |     libgl = dlopen("libGL.so.1", RTLD_LAZY | RTLD_LOCAL);
673 |     if (!libgl)
674 |         return GL3W_ERROR_LIBRARY_OPEN;
675 |     *(void **)(&glx_get_proc_address) = dlsym(libgl, "glXGetProcAddressARB");
676 |     return GL3W_OK;
677 | }
678 | 
679 | static void close_libgl(void) { dlclose(libgl); }
680 | 
681 | static GL3WglProc get_proc(const char *proc)
682 | {
683 |     GL3WglProc res;
684 |     res = glx_get_proc_address((const GLubyte *)proc);
685 |     if (!res)
686 |         *(void **)(&res) = dlsym(libgl, proc);
687 |     return res;
688 | }
689 | #endif
690 | 
691 | static struct { int major, minor; } version;
692 | 
693 | static int parse_version(void)
694 | {
695 |     if (!glGetIntegerv)
696 |         return GL3W_ERROR_INIT;
697 |     glGetIntegerv(GL_MAJOR_VERSION, &version.major);
698 |     glGetIntegerv(GL_MINOR_VERSION, &version.minor);
699 |     if (version.major == 0 && version.minor == 0)
700 |     {
701 |         // Query GL_VERSION in desktop GL 2.x, the string will start with "<major>.<minor>"
702 |         if (const char* gl_version = (const char*)glGetString(GL_VERSION))
703 |             sscanf(gl_version, "%d.%d", &version.major, &version.minor);
704 |     }
705 |     if (version.major < 2)
706 |         return GL3W_ERROR_OPENGL_VERSION;
707 |     return GL3W_OK;
708 | }
709 | 
710 | static void load_procs(GL3WGetProcAddressProc proc);
711 | 
712 | int imgl3wInit(void)
713 | {
714 |     int res = open_libgl();
715 |     if (res)
716 |         return res;
717 |     atexit(close_libgl);
718 |     return imgl3wInit2(get_proc);
719 | }
720 | 
721 | int imgl3wInit2(GL3WGetProcAddressProc proc)
722 | {
723 |     load_procs(proc);
724 |     return parse_version();
725 | }
726 | 
727 | int imgl3wIsSupported(int major, int minor)
728 | {
729 |     if (major < 2)
730 |         return 0;
731 |     if (version.major == major)
732 |         return version.minor >= minor;
733 |     return version.major >= major;
734 | }
735 | 
736 | GL3WglProc imgl3wGetProcAddress(const char *proc) { return get_proc(proc); }
737 | 
738 | static const char *proc_names[] = {
739 |     "glActiveTexture",
740 |     "glAttachShader",
741 |     "glBindBuffer",
742 |     "glBindSampler",
743 |     "glBindTexture",
744 |     "glBindVertexArray",
745 |     "glBlendEquation",
746 |     "glBlendEquationSeparate",
747 |     "glBlendFuncSeparate",
748 |     "glBufferData",
749 |     "glBufferSubData",
750 |     "glClear",
751 |     "glClearColor",
752 |     "glCompileShader",
753 |     "glCreateProgram",
754 |     "glCreateShader",
755 |     "glDeleteBuffers",
756 |     "glDeleteProgram",
757 |     "glDeleteShader",
758 |     "glDeleteTextures",
759 |     "glDeleteVertexArrays",
760 |     "glDetachShader",
761 |     "glDisable",
762 |     "glDisableVertexAttribArray",
763 |     "glDrawElements",
764 |     "glDrawElementsBaseVertex",
765 |     "glEnable",
766 |     "glEnableVertexAttribArray",
767 |     "glFlush",
768 |     "glGenBuffers",
769 |     "glGenTextures",
770 |     "glGenVertexArrays",
771 |     "glGetAttribLocation",
772 |     "glGetError",
773 |     "glGetIntegerv",
774 |     "glGetProgramInfoLog",
775 |     "glGetProgramiv",
776 |     "glGetShaderInfoLog",
777 |     "glGetShaderiv",
778 |     "glGetString",
779 |     "glGetStringi",
780 |     "glGetUniformLocation",
781 |     "glGetVertexAttribPointerv",
782 |     "glGetVertexAttribiv",
783 |     "glIsEnabled",
784 |     "glIsProgram",
785 |     "glLinkProgram",
786 |     "glPixelStorei",
787 |     "glPolygonMode",
788 |     "glReadPixels",
789 |     "glScissor",
790 |     "glShaderSource",
791 |     "glTexImage2D",
792 |     "glTexParameteri",
793 |     "glUniform1i",
794 |     "glUniformMatrix4fv",
795 |     "glUseProgram",
796 |     "glVertexAttribPointer",
797 |     "glViewport",
798 | };
799 | 
800 | GL3W_API union ImGL3WProcs imgl3wProcs;
801 | 
802 | static void load_procs(GL3WGetProcAddressProc proc)
803 | {
804 |     size_t i;
805 |     for (i = 0; i < ARRAY_SIZE(proc_names); i++)
806 |         imgl3wProcs.ptr[i] = proc(proc_names[i]);
807 | }
808 | 
809 | #ifdef __cplusplus
810 | }
811 | #endif
812 | #endif
813 | 
814 | 
815 | #endif /* IMGUI_IMPL_OPENGL3_LOADER_H */
816 | 


--------------------------------------------------------------------------------