diff --git a/demos/.gitignore b/demos/.gitignore index c799805..e6f937c 100644 --- a/demos/.gitignore +++ b/demos/.gitignore @@ -9,4 +9,5 @@ !assets/** !external/**/*.d !.gitignore -!compile_wasm.py \ No newline at end of file +!compile_wasm.py +!cimgui.bc \ No newline at end of file diff --git a/demos/assets/fonts/Ruda-Bold.ttf b/demos/assets/fonts/Ruda-Bold.ttf new file mode 100644 index 0000000..53ae69c Binary files /dev/null and b/demos/assets/fonts/Ruda-Bold.ttf differ diff --git a/demos/assets/shaders/base.fp b/demos/assets/shaders/base.fp new file mode 100644 index 0000000..043fa58 --- /dev/null +++ b/demos/assets/shaders/base.fp @@ -0,0 +1,42 @@ +precision mediump int; +precision mediump float; +precision lowp sampler2D; +precision lowp samplerCube; + +#ifdef GLES + #if __VERSION__ >290 + in mediump vec2 uv; + #else + varying mediump vec2 uv; + #endif +#else + #if __VERSION__ > 320 + in vec2 uv; + #else + varying vec2 uv; + #endif +#endif + +//layout(binding = 0)uniform sampler2D tex; + +uniform sampler2D tex; + +//layout(location = 0) out vec4 outColor; + +void main() { + + #ifdef GLES + #if __VERSION__ >290 + gl_FragColor = texture(tex,uv); + #else + gl_FragColor = texture2D(tex,uv); + #endif + #else + #if __VERSION__ > 320 + gl_FragColor = texture(tex,uv); + #else + gl_FragColor = texture2D(tex,uv); + #endif + #endif + if(gl_FragColor.a < 0.01)discard; +} diff --git a/demos/assets/shaders/base.vp b/demos/assets/shaders/base.vp new file mode 100644 index 0000000..50fc27e --- /dev/null +++ b/demos/assets/shaders/base.vp @@ -0,0 +1,55 @@ +precision highp float; +precision highp int; +precision lowp sampler2D; +precision lowp samplerCube; + +#ifdef GLES + #if __VERSION__ >290 + layout(location = 0) uniform vec4 matrix_1; + layout(location = 1) uniform vec4 matrix_2; + layout(location = 2) uniform vec4 uv_transform; + + layout(location = 0) in vec2 positions; + layout(location = 1) in vec2 tex_coords; + + out mediump vec2 uv; + #else + uniform vec4 matrix_1; + uniform vec4 matrix_2; + uniform vec4 uv_transform; + + attribute vec2 positions; + attribute vec2 tex_coords; + + varying mediump vec2 uv; + #endif +#else + #if __VERSION__ > 320 + layout(location = 0) uniform vec4 matrix_1; + layout(location = 1) uniform vec4 matrix_2; + layout(location = 2) uniform vec4 uv_transform; + + layout(location = 0) in vec2 positions; + layout(location = 1) in vec2 tex_coords; + + out vec2 uv; + #else + uniform vec4 matrix_1; + uniform vec4 matrix_2; + uniform vec4 uv_transform; + + attribute vec2 positions; + attribute vec2 tex_coords; + + varying vec2 uv; + #endif +#endif + +void main() { + + vec3 position = mat3(matrix_1.x,matrix_1.y,0,matrix_1.z,matrix_1.w,0,matrix_2.xy,1) * vec3(positions,1.0); + uv = tex_coords * uv_transform.zw + uv_transform.xy; + + gl_Position = vec4(position.xy,0,1.0); + +} diff --git a/demos/cimgui.bc b/demos/cimgui.bc new file mode 100644 index 0000000..e248fd9 Binary files /dev/null and b/demos/cimgui.bc differ diff --git a/demos/cimgui.dll b/demos/cimgui.dll new file mode 100644 index 0000000..ef645de Binary files /dev/null and b/demos/cimgui.dll differ diff --git a/demos/compile_wasm.py b/demos/compile_wasm.py index a650b9e..b34b5c6 100644 --- a/demos/compile_wasm.py +++ b/demos/compile_wasm.py @@ -36,8 +36,8 @@ clean = 0 demo = 0 sources = ['tests', 'source'] emc_flags = '-s USE_SDL=2 -s USE_SDL_IMAGE=2 -s SDL2_IMAGE_FORMATS="[\'png\']" --preload-file assets ' -ldc_flags = '--d-version=SDL_209 --d-version=BindSDL_Static --d-version=BindSDL_Image ' -import_paths = ['external/imports', '../source', 'utils/source'] +ldc_flags = '--d-version=SDL_209 --d-version=BindSDL_Static --d-version=BindSDL_Image --d-version=MM_USE_POSIX_THREADS ' +import_paths = ['external/sources', 'external/imports', 'external/wasm_imports', '../source', 'utils/source', 'simple/source'] for arg in sys.argv[1:]: if(arg == '-release'): @@ -74,18 +74,24 @@ for arg in sys.argv[1:]: print('unknown argument: ' + arg) exit() -compile(['external/imports/bindbc/sdl'], 'bindbc-sdl.bc') +compile(['external/wasm_imports/bindbc/sdl'], 'bindbc-sdl.bc') compile(['utils/source'], 'utils.bc') -compile(['simple/source'], 'demo.bc') +compile(['external/sources/mmutils'], 'mmutils.bc') +compile(['external/sources/glad'], 'glad.bc') +compile(['source'], 'demo.bc') if clean or os.path.exists('../ecs.bc') == 0 or os.path.isfile('../ecs.bc') == 0: compile(['../source'], '../ecs.bc') -emcc_cmd = 'emcc -v ' + shared_flags + emc_flags + '-s ALLOW_MEMORY_GROWTH=1 -s MALLOC=dlmalloc -s WASM=1 -o index.html ' +emcc_cmd = 'emcc -v ' + shared_flags + emc_flags + '-s ALLOW_MEMORY_GROWTH=1 -s MALLOC=dlmalloc -s FULL_ES2=1 -s WASM=1 -o index.html ' emcc_cmd += '../ecs.bc ' emcc_cmd += 'utils.bc ' emcc_cmd += 'bindbc-sdl.bc ' +emcc_cmd += 'glad.bc ' +emcc_cmd += 'cimgui.bc ' +emcc_cmd += 'nuklear.bc ' +emcc_cmd += 'mmutils.bc ' emcc_cmd += 'demo.bc ' print emcc_cmd diff --git a/demos/simple/dub.json b/demos/dub.json similarity index 57% rename from demos/simple/dub.json rename to demos/dub.json index 393840f..0bda382 100644 --- a/demos/simple/dub.json +++ b/demos/dub.json @@ -1,29 +1,21 @@ { - "name": "simple", + "name": "demo", "authors": [ "Michał Masiukiewicz", "Dawid Masiukiewicz" ], - "targetPath": "..", "description": "Dynamic Entity Component System simple example", "copyright": "Copyright © 2018-2019, Michał Masiukiewicz, Dawid Masiukiewicz", "license": "BSD 3-clause", - "sourcePaths" : ["source\/"], - "dflags-posix-ldc": [ - "-defaultlib=phobos2-ldc,druntime-ldc" - ], - "libs-windows-x86_64": ["../libs/windows/x64/SDL2","../libs/windows/x64/SDL2main","../libs/windows/x64/SDL2_Image"], - "dflagss": [ - "-betterC" - ], "dependencies": { - "bindbc-sdl":"0.13.0", - "ecs":{"path":"../../"}, - "ecs_utils":{"path":"../utils/"} + "ecs_utils":{"path":"utils/"} }, - "versions": [ - "SDL_2010", - "BindSDL_Image" + "sourcePaths": [ + "source" ], + "importPaths": [ + "source" + ], + "libs-windows-x86_64": ["libs/windows/x64/SDL2","libs/windows/x64/SDL2_Image","libs/windows/x64/cimgui"], "configurations" : [ { "name" : "default", @@ -41,7 +33,7 @@ ], "subConfigurations": { - "bindbc-sdl": "staticBC", + "bindbc-sdl":"staticBC", "ecs_utils":"betterC", "ecs":"library-betterC" } diff --git a/demos/external/sources/cimgui/cimgui.d b/demos/external/sources/cimgui/cimgui.d new file mode 100644 index 0000000..507f616 --- /dev/null +++ b/demos/external/sources/cimgui/cimgui.d @@ -0,0 +1,1990 @@ +//This file is automatically generated by generator.lua from https://github.com/cimgui/cimgui +//based on imgui.h file version "1.73" from Dear ImGui https://github.com/ocornut/imgui +module cimgui.cimgui; + +import core.stdc.stdarg; +//import core.stdc.stdio; + +extern (C): + +//alias ImU64 = ulong; + +//typedef unsigned long long ImU64; + +//UDT stuff +struct ImVec2_Simple +{ + float x; + float y; +} + +struct ImVec4_Simple +{ + float x; + float y; + float z; + float w; +} + +struct ImColor_Simple +{ + ImVec4_Simple Value; +} + +struct ImGuiContext; +struct ImDrawListSharedData; + +alias ImTextureID = void*; +alias ImGuiID = uint; +alias ImWchar = ushort; +alias ImGuiCol = int; +alias ImGuiCond = int; +alias ImGuiDataType = int; +alias ImGuiDir = int; +alias ImGuiKey = int; +alias ImGuiNavInput = int; +alias ImGuiMouseCursor = int; +alias ImGuiStyleVar = int; +alias ImDrawCornerFlags = int; +alias ImDrawListFlags = int; +alias ImFontAtlasFlags = int; +alias ImGuiBackendFlags = int; +alias ImGuiColorEditFlags = int; +alias ImGuiConfigFlags = int; +alias ImGuiComboFlags = int; +alias ImGuiDragDropFlags = int; +alias ImGuiFocusedFlags = int; +alias ImGuiHoveredFlags = int; +alias ImGuiInputTextFlags = int; +alias ImGuiSelectableFlags = int; +alias ImGuiTabBarFlags = int; +alias ImGuiTabItemFlags = int; +alias ImGuiTreeNodeFlags = int; +alias ImGuiWindowFlags = int; +alias ImGuiInputTextCallback = int function (ImGuiInputTextCallbackData* data); +alias ImGuiSizeCallback = void function (ImGuiSizeCallbackData* data); +alias ImS8 = byte; +alias ImU8 = ubyte; +alias ImS16 = short; +alias ImU16 = ushort; +alias ImS32 = int; +alias ImU32 = uint; +alias ImS64 = long; +alias ImU64 = ulong; +alias ImDrawCallback = void function (const(ImDrawList)* parent_list, const(ImDrawCmd)* cmd); +alias ImDrawIdx = ushort; + +struct ImVector +{ + int Size; + int Capacity; + void* Data; +} + +struct ImVector_float +{ + int Size; + int Capacity; + float* Data; +} + +struct ImVector_ImWchar +{ + int Size; + int Capacity; + ImWchar* Data; +} + +struct ImVector_ImDrawVert +{ + int Size; + int Capacity; + ImDrawVert* Data; +} + +struct ImVector_ImFontGlyph +{ + int Size; + int Capacity; + ImFontGlyph* Data; +} + +struct ImVector_ImGuiTextRange +{ + int Size; + int Capacity; + ImGuiTextRange* Data; +} + +struct ImVector_ImGuiStoragePair +{ + int Size; + int Capacity; + ImGuiStoragePair* Data; +} + +struct ImVector_ImDrawChannel +{ + int Size; + int Capacity; + ImDrawChannel* Data; +} + +struct ImVector_char +{ + int Size; + int Capacity; + char* Data; +} + +struct ImVector_ImU32 +{ + int Size; + int Capacity; + ImU32* Data; +} + +struct ImVector_ImFontAtlasCustomRect +{ + int Size; + int Capacity; + ImFontAtlasCustomRect* Data; +} + +struct ImVector_ImTextureID +{ + int Size; + int Capacity; + ImTextureID* Data; +} + +struct ImVector_ImFontConfig +{ + int Size; + int Capacity; + ImFontConfig* Data; +} + +struct ImVector_ImFontPtr +{ + int Size; + int Capacity; + ImFont** Data; +} + +struct ImVector_ImDrawCmd +{ + int Size; + int Capacity; + ImDrawCmd* Data; +} + +struct ImVector_ImVec4 +{ + int Size; + int Capacity; + ImVec4* Data; +} + +struct ImVector_ImDrawIdx +{ + int Size; + int Capacity; + ImDrawIdx* Data; +} + +struct ImVector_ImVec2 +{ + int Size; + int Capacity; + ImVec2* Data; +} + +struct ImVec2 +{ + float x; + float y; +} + +struct ImVec4 +{ + float x; + float y; + float z; + float w; +} + +enum ImGuiWindowFlags_ +{ + ImGuiWindowFlags_None = 0, + ImGuiWindowFlags_NoTitleBar = 1 << 0, + ImGuiWindowFlags_NoResize = 1 << 1, + ImGuiWindowFlags_NoMove = 1 << 2, + ImGuiWindowFlags_NoScrollbar = 1 << 3, + ImGuiWindowFlags_NoScrollWithMouse = 1 << 4, + ImGuiWindowFlags_NoCollapse = 1 << 5, + ImGuiWindowFlags_AlwaysAutoResize = 1 << 6, + ImGuiWindowFlags_NoBackground = 1 << 7, + ImGuiWindowFlags_NoSavedSettings = 1 << 8, + ImGuiWindowFlags_NoMouseInputs = 1 << 9, + ImGuiWindowFlags_MenuBar = 1 << 10, + ImGuiWindowFlags_HorizontalScrollbar = 1 << 11, + ImGuiWindowFlags_NoFocusOnAppearing = 1 << 12, + ImGuiWindowFlags_NoBringToFrontOnFocus = 1 << 13, + ImGuiWindowFlags_AlwaysVerticalScrollbar = 1 << 14, + ImGuiWindowFlags_AlwaysHorizontalScrollbar = 1 << 15, + ImGuiWindowFlags_AlwaysUseWindowPadding = 1 << 16, + ImGuiWindowFlags_NoNavInputs = 1 << 18, + ImGuiWindowFlags_NoNavFocus = 1 << 19, + ImGuiWindowFlags_UnsavedDocument = 1 << 20, + ImGuiWindowFlags_NoNav = ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus, + ImGuiWindowFlags_NoDecoration = ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoCollapse, + ImGuiWindowFlags_NoInputs = ImGuiWindowFlags_NoMouseInputs | ImGuiWindowFlags_NoNavInputs | ImGuiWindowFlags_NoNavFocus, + ImGuiWindowFlags_NavFlattened = 1 << 23, + ImGuiWindowFlags_ChildWindow = 1 << 24, + ImGuiWindowFlags_Tooltip = 1 << 25, + ImGuiWindowFlags_Popup = 1 << 26, + ImGuiWindowFlags_Modal = 1 << 27, + ImGuiWindowFlags_ChildMenu = 1 << 28 +} + +alias ImGuiWindowFlags_None = ImGuiWindowFlags_.ImGuiWindowFlags_None; +alias ImGuiWindowFlags_NoTitleBar = ImGuiWindowFlags_.ImGuiWindowFlags_NoTitleBar; +alias ImGuiWindowFlags_NoResize = ImGuiWindowFlags_.ImGuiWindowFlags_NoResize; +alias ImGuiWindowFlags_NoMove = ImGuiWindowFlags_.ImGuiWindowFlags_NoMove; +alias ImGuiWindowFlags_NoScrollbar = ImGuiWindowFlags_.ImGuiWindowFlags_NoScrollbar; +alias ImGuiWindowFlags_NoScrollWithMouse = ImGuiWindowFlags_.ImGuiWindowFlags_NoScrollWithMouse; +alias ImGuiWindowFlags_NoCollapse = ImGuiWindowFlags_.ImGuiWindowFlags_NoCollapse; +alias ImGuiWindowFlags_AlwaysAutoResize = ImGuiWindowFlags_.ImGuiWindowFlags_AlwaysAutoResize; +alias ImGuiWindowFlags_NoBackground = ImGuiWindowFlags_.ImGuiWindowFlags_NoBackground; +alias ImGuiWindowFlags_NoSavedSettings = ImGuiWindowFlags_.ImGuiWindowFlags_NoSavedSettings; +alias ImGuiWindowFlags_NoMouseInputs = ImGuiWindowFlags_.ImGuiWindowFlags_NoMouseInputs; +alias ImGuiWindowFlags_MenuBar = ImGuiWindowFlags_.ImGuiWindowFlags_MenuBar; +alias ImGuiWindowFlags_HorizontalScrollbar = ImGuiWindowFlags_.ImGuiWindowFlags_HorizontalScrollbar; +alias ImGuiWindowFlags_NoFocusOnAppearing = ImGuiWindowFlags_.ImGuiWindowFlags_NoFocusOnAppearing; +alias ImGuiWindowFlags_NoBringToFrontOnFocus = ImGuiWindowFlags_.ImGuiWindowFlags_NoBringToFrontOnFocus; +alias ImGuiWindowFlags_AlwaysVerticalScrollbar = ImGuiWindowFlags_.ImGuiWindowFlags_AlwaysVerticalScrollbar; +alias ImGuiWindowFlags_AlwaysHorizontalScrollbar = ImGuiWindowFlags_.ImGuiWindowFlags_AlwaysHorizontalScrollbar; +alias ImGuiWindowFlags_AlwaysUseWindowPadding = ImGuiWindowFlags_.ImGuiWindowFlags_AlwaysUseWindowPadding; +alias ImGuiWindowFlags_NoNavInputs = ImGuiWindowFlags_.ImGuiWindowFlags_NoNavInputs; +alias ImGuiWindowFlags_NoNavFocus = ImGuiWindowFlags_.ImGuiWindowFlags_NoNavFocus; +alias ImGuiWindowFlags_UnsavedDocument = ImGuiWindowFlags_.ImGuiWindowFlags_UnsavedDocument; +alias ImGuiWindowFlags_NoNav = ImGuiWindowFlags_.ImGuiWindowFlags_NoNav; +alias ImGuiWindowFlags_NoDecoration = ImGuiWindowFlags_.ImGuiWindowFlags_NoDecoration; +alias ImGuiWindowFlags_NoInputs = ImGuiWindowFlags_.ImGuiWindowFlags_NoInputs; +alias ImGuiWindowFlags_NavFlattened = ImGuiWindowFlags_.ImGuiWindowFlags_NavFlattened; +alias ImGuiWindowFlags_ChildWindow = ImGuiWindowFlags_.ImGuiWindowFlags_ChildWindow; +alias ImGuiWindowFlags_Tooltip = ImGuiWindowFlags_.ImGuiWindowFlags_Tooltip; +alias ImGuiWindowFlags_Popup = ImGuiWindowFlags_.ImGuiWindowFlags_Popup; +alias ImGuiWindowFlags_Modal = ImGuiWindowFlags_.ImGuiWindowFlags_Modal; +alias ImGuiWindowFlags_ChildMenu = ImGuiWindowFlags_.ImGuiWindowFlags_ChildMenu; + +enum ImGuiInputTextFlags_ +{ + ImGuiInputTextFlags_None = 0, + ImGuiInputTextFlags_CharsDecimal = 1 << 0, + ImGuiInputTextFlags_CharsHexadecimal = 1 << 1, + ImGuiInputTextFlags_CharsUppercase = 1 << 2, + ImGuiInputTextFlags_CharsNoBlank = 1 << 3, + ImGuiInputTextFlags_AutoSelectAll = 1 << 4, + ImGuiInputTextFlags_EnterReturnsTrue = 1 << 5, + ImGuiInputTextFlags_CallbackCompletion = 1 << 6, + ImGuiInputTextFlags_CallbackHistory = 1 << 7, + ImGuiInputTextFlags_CallbackAlways = 1 << 8, + ImGuiInputTextFlags_CallbackCharFilter = 1 << 9, + ImGuiInputTextFlags_AllowTabInput = 1 << 10, + ImGuiInputTextFlags_CtrlEnterForNewLine = 1 << 11, + ImGuiInputTextFlags_NoHorizontalScroll = 1 << 12, + ImGuiInputTextFlags_AlwaysInsertMode = 1 << 13, + ImGuiInputTextFlags_ReadOnly = 1 << 14, + ImGuiInputTextFlags_Password = 1 << 15, + ImGuiInputTextFlags_NoUndoRedo = 1 << 16, + ImGuiInputTextFlags_CharsScientific = 1 << 17, + ImGuiInputTextFlags_CallbackResize = 1 << 18, + ImGuiInputTextFlags_Multiline = 1 << 20, + ImGuiInputTextFlags_NoMarkEdited = 1 << 21 +} + +alias ImGuiInputTextFlags_None = ImGuiInputTextFlags_.ImGuiInputTextFlags_None; +alias ImGuiInputTextFlags_CharsDecimal = ImGuiInputTextFlags_.ImGuiInputTextFlags_CharsDecimal; +alias ImGuiInputTextFlags_CharsHexadecimal = ImGuiInputTextFlags_.ImGuiInputTextFlags_CharsHexadecimal; +alias ImGuiInputTextFlags_CharsUppercase = ImGuiInputTextFlags_.ImGuiInputTextFlags_CharsUppercase; +alias ImGuiInputTextFlags_CharsNoBlank = ImGuiInputTextFlags_.ImGuiInputTextFlags_CharsNoBlank; +alias ImGuiInputTextFlags_AutoSelectAll = ImGuiInputTextFlags_.ImGuiInputTextFlags_AutoSelectAll; +alias ImGuiInputTextFlags_EnterReturnsTrue = ImGuiInputTextFlags_.ImGuiInputTextFlags_EnterReturnsTrue; +alias ImGuiInputTextFlags_CallbackCompletion = ImGuiInputTextFlags_.ImGuiInputTextFlags_CallbackCompletion; +alias ImGuiInputTextFlags_CallbackHistory = ImGuiInputTextFlags_.ImGuiInputTextFlags_CallbackHistory; +alias ImGuiInputTextFlags_CallbackAlways = ImGuiInputTextFlags_.ImGuiInputTextFlags_CallbackAlways; +alias ImGuiInputTextFlags_CallbackCharFilter = ImGuiInputTextFlags_.ImGuiInputTextFlags_CallbackCharFilter; +alias ImGuiInputTextFlags_AllowTabInput = ImGuiInputTextFlags_.ImGuiInputTextFlags_AllowTabInput; +alias ImGuiInputTextFlags_CtrlEnterForNewLine = ImGuiInputTextFlags_.ImGuiInputTextFlags_CtrlEnterForNewLine; +alias ImGuiInputTextFlags_NoHorizontalScroll = ImGuiInputTextFlags_.ImGuiInputTextFlags_NoHorizontalScroll; +alias ImGuiInputTextFlags_AlwaysInsertMode = ImGuiInputTextFlags_.ImGuiInputTextFlags_AlwaysInsertMode; +alias ImGuiInputTextFlags_ReadOnly = ImGuiInputTextFlags_.ImGuiInputTextFlags_ReadOnly; +alias ImGuiInputTextFlags_Password = ImGuiInputTextFlags_.ImGuiInputTextFlags_Password; +alias ImGuiInputTextFlags_NoUndoRedo = ImGuiInputTextFlags_.ImGuiInputTextFlags_NoUndoRedo; +alias ImGuiInputTextFlags_CharsScientific = ImGuiInputTextFlags_.ImGuiInputTextFlags_CharsScientific; +alias ImGuiInputTextFlags_CallbackResize = ImGuiInputTextFlags_.ImGuiInputTextFlags_CallbackResize; +alias ImGuiInputTextFlags_Multiline = ImGuiInputTextFlags_.ImGuiInputTextFlags_Multiline; +alias ImGuiInputTextFlags_NoMarkEdited = ImGuiInputTextFlags_.ImGuiInputTextFlags_NoMarkEdited; + +enum ImGuiTreeNodeFlags_ +{ + ImGuiTreeNodeFlags_None = 0, + ImGuiTreeNodeFlags_Selected = 1 << 0, + ImGuiTreeNodeFlags_Framed = 1 << 1, + ImGuiTreeNodeFlags_AllowItemOverlap = 1 << 2, + ImGuiTreeNodeFlags_NoTreePushOnOpen = 1 << 3, + ImGuiTreeNodeFlags_NoAutoOpenOnLog = 1 << 4, + ImGuiTreeNodeFlags_DefaultOpen = 1 << 5, + ImGuiTreeNodeFlags_OpenOnDoubleClick = 1 << 6, + ImGuiTreeNodeFlags_OpenOnArrow = 1 << 7, + ImGuiTreeNodeFlags_Leaf = 1 << 8, + ImGuiTreeNodeFlags_Bullet = 1 << 9, + ImGuiTreeNodeFlags_FramePadding = 1 << 10, + ImGuiTreeNodeFlags_SpanAvailWidth = 1 << 11, + ImGuiTreeNodeFlags_SpanFullWidth = 1 << 12, + ImGuiTreeNodeFlags_NavLeftJumpsBackHere = 1 << 13, + ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_NoTreePushOnOpen | ImGuiTreeNodeFlags_NoAutoOpenOnLog +} + +alias ImGuiTreeNodeFlags_None = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_None; +alias ImGuiTreeNodeFlags_Selected = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_Selected; +alias ImGuiTreeNodeFlags_Framed = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_Framed; +alias ImGuiTreeNodeFlags_AllowItemOverlap = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_AllowItemOverlap; +alias ImGuiTreeNodeFlags_NoTreePushOnOpen = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_NoTreePushOnOpen; +alias ImGuiTreeNodeFlags_NoAutoOpenOnLog = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_NoAutoOpenOnLog; +alias ImGuiTreeNodeFlags_DefaultOpen = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_DefaultOpen; +alias ImGuiTreeNodeFlags_OpenOnDoubleClick = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_OpenOnDoubleClick; +alias ImGuiTreeNodeFlags_OpenOnArrow = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_OpenOnArrow; +alias ImGuiTreeNodeFlags_Leaf = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_Leaf; +alias ImGuiTreeNodeFlags_Bullet = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_Bullet; +alias ImGuiTreeNodeFlags_FramePadding = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_FramePadding; +alias ImGuiTreeNodeFlags_SpanAvailWidth = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_SpanAvailWidth; +alias ImGuiTreeNodeFlags_SpanFullWidth = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_SpanFullWidth; +alias ImGuiTreeNodeFlags_NavLeftJumpsBackHere = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_NavLeftJumpsBackHere; +alias ImGuiTreeNodeFlags_CollapsingHeader = ImGuiTreeNodeFlags_.ImGuiTreeNodeFlags_CollapsingHeader; + +enum ImGuiSelectableFlags_ +{ + ImGuiSelectableFlags_None = 0, + ImGuiSelectableFlags_DontClosePopups = 1 << 0, + ImGuiSelectableFlags_SpanAllColumns = 1 << 1, + ImGuiSelectableFlags_AllowDoubleClick = 1 << 2, + ImGuiSelectableFlags_Disabled = 1 << 3, + ImGuiSelectableFlags_AllowItemOverlap = 1 << 4 +} + +alias ImGuiSelectableFlags_None = ImGuiSelectableFlags_.ImGuiSelectableFlags_None; +alias ImGuiSelectableFlags_DontClosePopups = ImGuiSelectableFlags_.ImGuiSelectableFlags_DontClosePopups; +alias ImGuiSelectableFlags_SpanAllColumns = ImGuiSelectableFlags_.ImGuiSelectableFlags_SpanAllColumns; +alias ImGuiSelectableFlags_AllowDoubleClick = ImGuiSelectableFlags_.ImGuiSelectableFlags_AllowDoubleClick; +alias ImGuiSelectableFlags_Disabled = ImGuiSelectableFlags_.ImGuiSelectableFlags_Disabled; +alias ImGuiSelectableFlags_AllowItemOverlap = ImGuiSelectableFlags_.ImGuiSelectableFlags_AllowItemOverlap; + +enum ImGuiComboFlags_ +{ + ImGuiComboFlags_None = 0, + ImGuiComboFlags_PopupAlignLeft = 1 << 0, + ImGuiComboFlags_HeightSmall = 1 << 1, + ImGuiComboFlags_HeightRegular = 1 << 2, + ImGuiComboFlags_HeightLarge = 1 << 3, + ImGuiComboFlags_HeightLargest = 1 << 4, + ImGuiComboFlags_NoArrowButton = 1 << 5, + ImGuiComboFlags_NoPreview = 1 << 6, + ImGuiComboFlags_HeightMask_ = ImGuiComboFlags_HeightSmall | ImGuiComboFlags_HeightRegular | ImGuiComboFlags_HeightLarge | ImGuiComboFlags_HeightLargest +} + +alias ImGuiComboFlags_None = ImGuiComboFlags_.ImGuiComboFlags_None; +alias ImGuiComboFlags_PopupAlignLeft = ImGuiComboFlags_.ImGuiComboFlags_PopupAlignLeft; +alias ImGuiComboFlags_HeightSmall = ImGuiComboFlags_.ImGuiComboFlags_HeightSmall; +alias ImGuiComboFlags_HeightRegular = ImGuiComboFlags_.ImGuiComboFlags_HeightRegular; +alias ImGuiComboFlags_HeightLarge = ImGuiComboFlags_.ImGuiComboFlags_HeightLarge; +alias ImGuiComboFlags_HeightLargest = ImGuiComboFlags_.ImGuiComboFlags_HeightLargest; +alias ImGuiComboFlags_NoArrowButton = ImGuiComboFlags_.ImGuiComboFlags_NoArrowButton; +alias ImGuiComboFlags_NoPreview = ImGuiComboFlags_.ImGuiComboFlags_NoPreview; +alias ImGuiComboFlags_HeightMask_ = ImGuiComboFlags_.ImGuiComboFlags_HeightMask_; + +enum ImGuiTabBarFlags_ +{ + ImGuiTabBarFlags_None = 0, + ImGuiTabBarFlags_Reorderable = 1 << 0, + ImGuiTabBarFlags_AutoSelectNewTabs = 1 << 1, + ImGuiTabBarFlags_TabListPopupButton = 1 << 2, + ImGuiTabBarFlags_NoCloseWithMiddleMouseButton = 1 << 3, + ImGuiTabBarFlags_NoTabListScrollingButtons = 1 << 4, + ImGuiTabBarFlags_NoTooltip = 1 << 5, + ImGuiTabBarFlags_FittingPolicyResizeDown = 1 << 6, + ImGuiTabBarFlags_FittingPolicyScroll = 1 << 7, + ImGuiTabBarFlags_FittingPolicyMask_ = ImGuiTabBarFlags_FittingPolicyResizeDown | ImGuiTabBarFlags_FittingPolicyScroll, + ImGuiTabBarFlags_FittingPolicyDefault_ = ImGuiTabBarFlags_FittingPolicyResizeDown +} + +alias ImGuiTabBarFlags_None = ImGuiTabBarFlags_.ImGuiTabBarFlags_None; +alias ImGuiTabBarFlags_Reorderable = ImGuiTabBarFlags_.ImGuiTabBarFlags_Reorderable; +alias ImGuiTabBarFlags_AutoSelectNewTabs = ImGuiTabBarFlags_.ImGuiTabBarFlags_AutoSelectNewTabs; +alias ImGuiTabBarFlags_TabListPopupButton = ImGuiTabBarFlags_.ImGuiTabBarFlags_TabListPopupButton; +alias ImGuiTabBarFlags_NoCloseWithMiddleMouseButton = ImGuiTabBarFlags_.ImGuiTabBarFlags_NoCloseWithMiddleMouseButton; +alias ImGuiTabBarFlags_NoTabListScrollingButtons = ImGuiTabBarFlags_.ImGuiTabBarFlags_NoTabListScrollingButtons; +alias ImGuiTabBarFlags_NoTooltip = ImGuiTabBarFlags_.ImGuiTabBarFlags_NoTooltip; +alias ImGuiTabBarFlags_FittingPolicyResizeDown = ImGuiTabBarFlags_.ImGuiTabBarFlags_FittingPolicyResizeDown; +alias ImGuiTabBarFlags_FittingPolicyScroll = ImGuiTabBarFlags_.ImGuiTabBarFlags_FittingPolicyScroll; +alias ImGuiTabBarFlags_FittingPolicyMask_ = ImGuiTabBarFlags_.ImGuiTabBarFlags_FittingPolicyMask_; +alias ImGuiTabBarFlags_FittingPolicyDefault_ = ImGuiTabBarFlags_.ImGuiTabBarFlags_FittingPolicyDefault_; + +enum ImGuiTabItemFlags_ +{ + ImGuiTabItemFlags_None = 0, + ImGuiTabItemFlags_UnsavedDocument = 1 << 0, + ImGuiTabItemFlags_SetSelected = 1 << 1, + ImGuiTabItemFlags_NoCloseWithMiddleMouseButton = 1 << 2, + ImGuiTabItemFlags_NoPushId = 1 << 3 +} + +alias ImGuiTabItemFlags_None = ImGuiTabItemFlags_.ImGuiTabItemFlags_None; +alias ImGuiTabItemFlags_UnsavedDocument = ImGuiTabItemFlags_.ImGuiTabItemFlags_UnsavedDocument; +alias ImGuiTabItemFlags_SetSelected = ImGuiTabItemFlags_.ImGuiTabItemFlags_SetSelected; +alias ImGuiTabItemFlags_NoCloseWithMiddleMouseButton = ImGuiTabItemFlags_.ImGuiTabItemFlags_NoCloseWithMiddleMouseButton; +alias ImGuiTabItemFlags_NoPushId = ImGuiTabItemFlags_.ImGuiTabItemFlags_NoPushId; + +enum ImGuiFocusedFlags_ +{ + ImGuiFocusedFlags_None = 0, + ImGuiFocusedFlags_ChildWindows = 1 << 0, + ImGuiFocusedFlags_RootWindow = 1 << 1, + ImGuiFocusedFlags_AnyWindow = 1 << 2, + ImGuiFocusedFlags_RootAndChildWindows = ImGuiFocusedFlags_RootWindow | ImGuiFocusedFlags_ChildWindows +} + +alias ImGuiFocusedFlags_None = ImGuiFocusedFlags_.ImGuiFocusedFlags_None; +alias ImGuiFocusedFlags_ChildWindows = ImGuiFocusedFlags_.ImGuiFocusedFlags_ChildWindows; +alias ImGuiFocusedFlags_RootWindow = ImGuiFocusedFlags_.ImGuiFocusedFlags_RootWindow; +alias ImGuiFocusedFlags_AnyWindow = ImGuiFocusedFlags_.ImGuiFocusedFlags_AnyWindow; +alias ImGuiFocusedFlags_RootAndChildWindows = ImGuiFocusedFlags_.ImGuiFocusedFlags_RootAndChildWindows; + +enum ImGuiHoveredFlags_ +{ + ImGuiHoveredFlags_None = 0, + ImGuiHoveredFlags_ChildWindows = 1 << 0, + ImGuiHoveredFlags_RootWindow = 1 << 1, + ImGuiHoveredFlags_AnyWindow = 1 << 2, + ImGuiHoveredFlags_AllowWhenBlockedByPopup = 1 << 3, + ImGuiHoveredFlags_AllowWhenBlockedByActiveItem = 1 << 5, + ImGuiHoveredFlags_AllowWhenOverlapped = 1 << 6, + ImGuiHoveredFlags_AllowWhenDisabled = 1 << 7, + ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_AllowWhenBlockedByPopup | ImGuiHoveredFlags_AllowWhenBlockedByActiveItem | ImGuiHoveredFlags_AllowWhenOverlapped, + ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_RootWindow | ImGuiHoveredFlags_ChildWindows +} + +alias ImGuiHoveredFlags_None = ImGuiHoveredFlags_.ImGuiHoveredFlags_None; +alias ImGuiHoveredFlags_ChildWindows = ImGuiHoveredFlags_.ImGuiHoveredFlags_ChildWindows; +alias ImGuiHoveredFlags_RootWindow = ImGuiHoveredFlags_.ImGuiHoveredFlags_RootWindow; +alias ImGuiHoveredFlags_AnyWindow = ImGuiHoveredFlags_.ImGuiHoveredFlags_AnyWindow; +alias ImGuiHoveredFlags_AllowWhenBlockedByPopup = ImGuiHoveredFlags_.ImGuiHoveredFlags_AllowWhenBlockedByPopup; +alias ImGuiHoveredFlags_AllowWhenBlockedByActiveItem = ImGuiHoveredFlags_.ImGuiHoveredFlags_AllowWhenBlockedByActiveItem; +alias ImGuiHoveredFlags_AllowWhenOverlapped = ImGuiHoveredFlags_.ImGuiHoveredFlags_AllowWhenOverlapped; +alias ImGuiHoveredFlags_AllowWhenDisabled = ImGuiHoveredFlags_.ImGuiHoveredFlags_AllowWhenDisabled; +alias ImGuiHoveredFlags_RectOnly = ImGuiHoveredFlags_.ImGuiHoveredFlags_RectOnly; +alias ImGuiHoveredFlags_RootAndChildWindows = ImGuiHoveredFlags_.ImGuiHoveredFlags_RootAndChildWindows; + +enum ImGuiDragDropFlags_ +{ + ImGuiDragDropFlags_None = 0, + ImGuiDragDropFlags_SourceNoPreviewTooltip = 1 << 0, + ImGuiDragDropFlags_SourceNoDisableHover = 1 << 1, + ImGuiDragDropFlags_SourceNoHoldToOpenOthers = 1 << 2, + ImGuiDragDropFlags_SourceAllowNullID = 1 << 3, + ImGuiDragDropFlags_SourceExtern = 1 << 4, + ImGuiDragDropFlags_SourceAutoExpirePayload = 1 << 5, + ImGuiDragDropFlags_AcceptBeforeDelivery = 1 << 10, + ImGuiDragDropFlags_AcceptNoDrawDefaultRect = 1 << 11, + ImGuiDragDropFlags_AcceptNoPreviewTooltip = 1 << 12, + ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_AcceptBeforeDelivery | ImGuiDragDropFlags_AcceptNoDrawDefaultRect +} + +alias ImGuiDragDropFlags_None = ImGuiDragDropFlags_.ImGuiDragDropFlags_None; +alias ImGuiDragDropFlags_SourceNoPreviewTooltip = ImGuiDragDropFlags_.ImGuiDragDropFlags_SourceNoPreviewTooltip; +alias ImGuiDragDropFlags_SourceNoDisableHover = ImGuiDragDropFlags_.ImGuiDragDropFlags_SourceNoDisableHover; +alias ImGuiDragDropFlags_SourceNoHoldToOpenOthers = ImGuiDragDropFlags_.ImGuiDragDropFlags_SourceNoHoldToOpenOthers; +alias ImGuiDragDropFlags_SourceAllowNullID = ImGuiDragDropFlags_.ImGuiDragDropFlags_SourceAllowNullID; +alias ImGuiDragDropFlags_SourceExtern = ImGuiDragDropFlags_.ImGuiDragDropFlags_SourceExtern; +alias ImGuiDragDropFlags_SourceAutoExpirePayload = ImGuiDragDropFlags_.ImGuiDragDropFlags_SourceAutoExpirePayload; +alias ImGuiDragDropFlags_AcceptBeforeDelivery = ImGuiDragDropFlags_.ImGuiDragDropFlags_AcceptBeforeDelivery; +alias ImGuiDragDropFlags_AcceptNoDrawDefaultRect = ImGuiDragDropFlags_.ImGuiDragDropFlags_AcceptNoDrawDefaultRect; +alias ImGuiDragDropFlags_AcceptNoPreviewTooltip = ImGuiDragDropFlags_.ImGuiDragDropFlags_AcceptNoPreviewTooltip; +alias ImGuiDragDropFlags_AcceptPeekOnly = ImGuiDragDropFlags_.ImGuiDragDropFlags_AcceptPeekOnly; + +enum ImGuiDataType_ +{ + ImGuiDataType_S8 = 0, + ImGuiDataType_U8 = 1, + ImGuiDataType_S16 = 2, + ImGuiDataType_U16 = 3, + ImGuiDataType_S32 = 4, + ImGuiDataType_U32 = 5, + ImGuiDataType_S64 = 6, + ImGuiDataType_U64 = 7, + ImGuiDataType_Float = 8, + ImGuiDataType_Double = 9, + ImGuiDataType_COUNT = 10 +} + +alias ImGuiDataType_S8 = ImGuiDataType_.ImGuiDataType_S8; +alias ImGuiDataType_U8 = ImGuiDataType_.ImGuiDataType_U8; +alias ImGuiDataType_S16 = ImGuiDataType_.ImGuiDataType_S16; +alias ImGuiDataType_U16 = ImGuiDataType_.ImGuiDataType_U16; +alias ImGuiDataType_S32 = ImGuiDataType_.ImGuiDataType_S32; +alias ImGuiDataType_U32 = ImGuiDataType_.ImGuiDataType_U32; +alias ImGuiDataType_S64 = ImGuiDataType_.ImGuiDataType_S64; +alias ImGuiDataType_U64 = ImGuiDataType_.ImGuiDataType_U64; +alias ImGuiDataType_Float = ImGuiDataType_.ImGuiDataType_Float; +alias ImGuiDataType_Double = ImGuiDataType_.ImGuiDataType_Double; +alias ImGuiDataType_COUNT = ImGuiDataType_.ImGuiDataType_COUNT; + +enum ImGuiDir_ +{ + ImGuiDir_None = -1, + ImGuiDir_Left = 0, + ImGuiDir_Right = 1, + ImGuiDir_Up = 2, + ImGuiDir_Down = 3, + ImGuiDir_COUNT = 4 +} + +alias ImGuiDir_None = ImGuiDir_.ImGuiDir_None; +alias ImGuiDir_Left = ImGuiDir_.ImGuiDir_Left; +alias ImGuiDir_Right = ImGuiDir_.ImGuiDir_Right; +alias ImGuiDir_Up = ImGuiDir_.ImGuiDir_Up; +alias ImGuiDir_Down = ImGuiDir_.ImGuiDir_Down; +alias ImGuiDir_COUNT = ImGuiDir_.ImGuiDir_COUNT; + +enum ImGuiKey_ +{ + ImGuiKey_Tab = 0, + ImGuiKey_LeftArrow = 1, + ImGuiKey_RightArrow = 2, + ImGuiKey_UpArrow = 3, + ImGuiKey_DownArrow = 4, + ImGuiKey_PageUp = 5, + ImGuiKey_PageDown = 6, + ImGuiKey_Home = 7, + ImGuiKey_End = 8, + ImGuiKey_Insert = 9, + ImGuiKey_Delete = 10, + ImGuiKey_Backspace = 11, + ImGuiKey_Space = 12, + ImGuiKey_Enter = 13, + ImGuiKey_Escape = 14, + ImGuiKey_KeyPadEnter = 15, + ImGuiKey_A = 16, + ImGuiKey_C = 17, + ImGuiKey_V = 18, + ImGuiKey_X = 19, + ImGuiKey_Y = 20, + ImGuiKey_Z = 21, + ImGuiKey_COUNT = 22 +} + +alias ImGuiKey_Tab = ImGuiKey_.ImGuiKey_Tab; +alias ImGuiKey_LeftArrow = ImGuiKey_.ImGuiKey_LeftArrow; +alias ImGuiKey_RightArrow = ImGuiKey_.ImGuiKey_RightArrow; +alias ImGuiKey_UpArrow = ImGuiKey_.ImGuiKey_UpArrow; +alias ImGuiKey_DownArrow = ImGuiKey_.ImGuiKey_DownArrow; +alias ImGuiKey_PageUp = ImGuiKey_.ImGuiKey_PageUp; +alias ImGuiKey_PageDown = ImGuiKey_.ImGuiKey_PageDown; +alias ImGuiKey_Home = ImGuiKey_.ImGuiKey_Home; +alias ImGuiKey_End = ImGuiKey_.ImGuiKey_End; +alias ImGuiKey_Insert = ImGuiKey_.ImGuiKey_Insert; +alias ImGuiKey_Delete = ImGuiKey_.ImGuiKey_Delete; +alias ImGuiKey_Backspace = ImGuiKey_.ImGuiKey_Backspace; +alias ImGuiKey_Space = ImGuiKey_.ImGuiKey_Space; +alias ImGuiKey_Enter = ImGuiKey_.ImGuiKey_Enter; +alias ImGuiKey_Escape = ImGuiKey_.ImGuiKey_Escape; +alias ImGuiKey_KeyPadEnter = ImGuiKey_.ImGuiKey_KeyPadEnter; +alias ImGuiKey_A = ImGuiKey_.ImGuiKey_A; +alias ImGuiKey_C = ImGuiKey_.ImGuiKey_C; +alias ImGuiKey_V = ImGuiKey_.ImGuiKey_V; +alias ImGuiKey_X = ImGuiKey_.ImGuiKey_X; +alias ImGuiKey_Y = ImGuiKey_.ImGuiKey_Y; +alias ImGuiKey_Z = ImGuiKey_.ImGuiKey_Z; +alias ImGuiKey_COUNT = ImGuiKey_.ImGuiKey_COUNT; + +enum ImGuiNavInput_ +{ + ImGuiNavInput_Activate = 0, + ImGuiNavInput_Cancel = 1, + ImGuiNavInput_Input = 2, + ImGuiNavInput_Menu = 3, + ImGuiNavInput_DpadLeft = 4, + ImGuiNavInput_DpadRight = 5, + ImGuiNavInput_DpadUp = 6, + ImGuiNavInput_DpadDown = 7, + ImGuiNavInput_LStickLeft = 8, + ImGuiNavInput_LStickRight = 9, + ImGuiNavInput_LStickUp = 10, + ImGuiNavInput_LStickDown = 11, + ImGuiNavInput_FocusPrev = 12, + ImGuiNavInput_FocusNext = 13, + ImGuiNavInput_TweakSlow = 14, + ImGuiNavInput_TweakFast = 15, + ImGuiNavInput_KeyMenu_ = 16, + ImGuiNavInput_KeyTab_ = 17, + ImGuiNavInput_KeyLeft_ = 18, + ImGuiNavInput_KeyRight_ = 19, + ImGuiNavInput_KeyUp_ = 20, + ImGuiNavInput_KeyDown_ = 21, + ImGuiNavInput_COUNT = 22, + ImGuiNavInput_InternalStart_ = ImGuiNavInput_KeyMenu_ +} + +alias ImGuiNavInput_Activate = ImGuiNavInput_.ImGuiNavInput_Activate; +alias ImGuiNavInput_Cancel = ImGuiNavInput_.ImGuiNavInput_Cancel; +alias ImGuiNavInput_Input = ImGuiNavInput_.ImGuiNavInput_Input; +alias ImGuiNavInput_Menu = ImGuiNavInput_.ImGuiNavInput_Menu; +alias ImGuiNavInput_DpadLeft = ImGuiNavInput_.ImGuiNavInput_DpadLeft; +alias ImGuiNavInput_DpadRight = ImGuiNavInput_.ImGuiNavInput_DpadRight; +alias ImGuiNavInput_DpadUp = ImGuiNavInput_.ImGuiNavInput_DpadUp; +alias ImGuiNavInput_DpadDown = ImGuiNavInput_.ImGuiNavInput_DpadDown; +alias ImGuiNavInput_LStickLeft = ImGuiNavInput_.ImGuiNavInput_LStickLeft; +alias ImGuiNavInput_LStickRight = ImGuiNavInput_.ImGuiNavInput_LStickRight; +alias ImGuiNavInput_LStickUp = ImGuiNavInput_.ImGuiNavInput_LStickUp; +alias ImGuiNavInput_LStickDown = ImGuiNavInput_.ImGuiNavInput_LStickDown; +alias ImGuiNavInput_FocusPrev = ImGuiNavInput_.ImGuiNavInput_FocusPrev; +alias ImGuiNavInput_FocusNext = ImGuiNavInput_.ImGuiNavInput_FocusNext; +alias ImGuiNavInput_TweakSlow = ImGuiNavInput_.ImGuiNavInput_TweakSlow; +alias ImGuiNavInput_TweakFast = ImGuiNavInput_.ImGuiNavInput_TweakFast; +alias ImGuiNavInput_KeyMenu_ = ImGuiNavInput_.ImGuiNavInput_KeyMenu_; +alias ImGuiNavInput_KeyTab_ = ImGuiNavInput_.ImGuiNavInput_KeyTab_; +alias ImGuiNavInput_KeyLeft_ = ImGuiNavInput_.ImGuiNavInput_KeyLeft_; +alias ImGuiNavInput_KeyRight_ = ImGuiNavInput_.ImGuiNavInput_KeyRight_; +alias ImGuiNavInput_KeyUp_ = ImGuiNavInput_.ImGuiNavInput_KeyUp_; +alias ImGuiNavInput_KeyDown_ = ImGuiNavInput_.ImGuiNavInput_KeyDown_; +alias ImGuiNavInput_COUNT = ImGuiNavInput_.ImGuiNavInput_COUNT; +alias ImGuiNavInput_InternalStart_ = ImGuiNavInput_.ImGuiNavInput_InternalStart_; + +enum ImGuiConfigFlags_ +{ + ImGuiConfigFlags_None = 0, + ImGuiConfigFlags_NavEnableKeyboard = 1 << 0, + ImGuiConfigFlags_NavEnableGamepad = 1 << 1, + ImGuiConfigFlags_NavEnableSetMousePos = 1 << 2, + ImGuiConfigFlags_NavNoCaptureKeyboard = 1 << 3, + ImGuiConfigFlags_NoMouse = 1 << 4, + ImGuiConfigFlags_NoMouseCursorChange = 1 << 5, + ImGuiConfigFlags_IsSRGB = 1 << 20, + ImGuiConfigFlags_IsTouchScreen = 1 << 21 +} + +alias ImGuiConfigFlags_None = ImGuiConfigFlags_.ImGuiConfigFlags_None; +alias ImGuiConfigFlags_NavEnableKeyboard = ImGuiConfigFlags_.ImGuiConfigFlags_NavEnableKeyboard; +alias ImGuiConfigFlags_NavEnableGamepad = ImGuiConfigFlags_.ImGuiConfigFlags_NavEnableGamepad; +alias ImGuiConfigFlags_NavEnableSetMousePos = ImGuiConfigFlags_.ImGuiConfigFlags_NavEnableSetMousePos; +alias ImGuiConfigFlags_NavNoCaptureKeyboard = ImGuiConfigFlags_.ImGuiConfigFlags_NavNoCaptureKeyboard; +alias ImGuiConfigFlags_NoMouse = ImGuiConfigFlags_.ImGuiConfigFlags_NoMouse; +alias ImGuiConfigFlags_NoMouseCursorChange = ImGuiConfigFlags_.ImGuiConfigFlags_NoMouseCursorChange; +alias ImGuiConfigFlags_IsSRGB = ImGuiConfigFlags_.ImGuiConfigFlags_IsSRGB; +alias ImGuiConfigFlags_IsTouchScreen = ImGuiConfigFlags_.ImGuiConfigFlags_IsTouchScreen; + +enum ImGuiBackendFlags_ +{ + ImGuiBackendFlags_None = 0, + ImGuiBackendFlags_HasGamepad = 1 << 0, + ImGuiBackendFlags_HasMouseCursors = 1 << 1, + ImGuiBackendFlags_HasSetMousePos = 1 << 2, + ImGuiBackendFlags_RendererHasVtxOffset = 1 << 3 +} + +alias ImGuiBackendFlags_None = ImGuiBackendFlags_.ImGuiBackendFlags_None; +alias ImGuiBackendFlags_HasGamepad = ImGuiBackendFlags_.ImGuiBackendFlags_HasGamepad; +alias ImGuiBackendFlags_HasMouseCursors = ImGuiBackendFlags_.ImGuiBackendFlags_HasMouseCursors; +alias ImGuiBackendFlags_HasSetMousePos = ImGuiBackendFlags_.ImGuiBackendFlags_HasSetMousePos; +alias ImGuiBackendFlags_RendererHasVtxOffset = ImGuiBackendFlags_.ImGuiBackendFlags_RendererHasVtxOffset; + +enum ImGuiCol_ +{ + ImGuiCol_Text = 0, + ImGuiCol_TextDisabled = 1, + ImGuiCol_WindowBg = 2, + ImGuiCol_ChildBg = 3, + ImGuiCol_PopupBg = 4, + ImGuiCol_Border = 5, + ImGuiCol_BorderShadow = 6, + ImGuiCol_FrameBg = 7, + ImGuiCol_FrameBgHovered = 8, + ImGuiCol_FrameBgActive = 9, + ImGuiCol_TitleBg = 10, + ImGuiCol_TitleBgActive = 11, + ImGuiCol_TitleBgCollapsed = 12, + ImGuiCol_MenuBarBg = 13, + ImGuiCol_ScrollbarBg = 14, + ImGuiCol_ScrollbarGrab = 15, + ImGuiCol_ScrollbarGrabHovered = 16, + ImGuiCol_ScrollbarGrabActive = 17, + ImGuiCol_CheckMark = 18, + ImGuiCol_SliderGrab = 19, + ImGuiCol_SliderGrabActive = 20, + ImGuiCol_Button = 21, + ImGuiCol_ButtonHovered = 22, + ImGuiCol_ButtonActive = 23, + ImGuiCol_Header = 24, + ImGuiCol_HeaderHovered = 25, + ImGuiCol_HeaderActive = 26, + ImGuiCol_Separator = 27, + ImGuiCol_SeparatorHovered = 28, + ImGuiCol_SeparatorActive = 29, + ImGuiCol_ResizeGrip = 30, + ImGuiCol_ResizeGripHovered = 31, + ImGuiCol_ResizeGripActive = 32, + ImGuiCol_Tab = 33, + ImGuiCol_TabHovered = 34, + ImGuiCol_TabActive = 35, + ImGuiCol_TabUnfocused = 36, + ImGuiCol_TabUnfocusedActive = 37, + ImGuiCol_PlotLines = 38, + ImGuiCol_PlotLinesHovered = 39, + ImGuiCol_PlotHistogram = 40, + ImGuiCol_PlotHistogramHovered = 41, + ImGuiCol_TextSelectedBg = 42, + ImGuiCol_DragDropTarget = 43, + ImGuiCol_NavHighlight = 44, + ImGuiCol_NavWindowingHighlight = 45, + ImGuiCol_NavWindowingDimBg = 46, + ImGuiCol_ModalWindowDimBg = 47, + ImGuiCol_COUNT = 48 +} + +alias ImGuiCol_Text = ImGuiCol_.ImGuiCol_Text; +alias ImGuiCol_TextDisabled = ImGuiCol_.ImGuiCol_TextDisabled; +alias ImGuiCol_WindowBg = ImGuiCol_.ImGuiCol_WindowBg; +alias ImGuiCol_ChildBg = ImGuiCol_.ImGuiCol_ChildBg; +alias ImGuiCol_PopupBg = ImGuiCol_.ImGuiCol_PopupBg; +alias ImGuiCol_Border = ImGuiCol_.ImGuiCol_Border; +alias ImGuiCol_BorderShadow = ImGuiCol_.ImGuiCol_BorderShadow; +alias ImGuiCol_FrameBg = ImGuiCol_.ImGuiCol_FrameBg; +alias ImGuiCol_FrameBgHovered = ImGuiCol_.ImGuiCol_FrameBgHovered; +alias ImGuiCol_FrameBgActive = ImGuiCol_.ImGuiCol_FrameBgActive; +alias ImGuiCol_TitleBg = ImGuiCol_.ImGuiCol_TitleBg; +alias ImGuiCol_TitleBgActive = ImGuiCol_.ImGuiCol_TitleBgActive; +alias ImGuiCol_TitleBgCollapsed = ImGuiCol_.ImGuiCol_TitleBgCollapsed; +alias ImGuiCol_MenuBarBg = ImGuiCol_.ImGuiCol_MenuBarBg; +alias ImGuiCol_ScrollbarBg = ImGuiCol_.ImGuiCol_ScrollbarBg; +alias ImGuiCol_ScrollbarGrab = ImGuiCol_.ImGuiCol_ScrollbarGrab; +alias ImGuiCol_ScrollbarGrabHovered = ImGuiCol_.ImGuiCol_ScrollbarGrabHovered; +alias ImGuiCol_ScrollbarGrabActive = ImGuiCol_.ImGuiCol_ScrollbarGrabActive; +alias ImGuiCol_CheckMark = ImGuiCol_.ImGuiCol_CheckMark; +alias ImGuiCol_SliderGrab = ImGuiCol_.ImGuiCol_SliderGrab; +alias ImGuiCol_SliderGrabActive = ImGuiCol_.ImGuiCol_SliderGrabActive; +alias ImGuiCol_Button = ImGuiCol_.ImGuiCol_Button; +alias ImGuiCol_ButtonHovered = ImGuiCol_.ImGuiCol_ButtonHovered; +alias ImGuiCol_ButtonActive = ImGuiCol_.ImGuiCol_ButtonActive; +alias ImGuiCol_Header = ImGuiCol_.ImGuiCol_Header; +alias ImGuiCol_HeaderHovered = ImGuiCol_.ImGuiCol_HeaderHovered; +alias ImGuiCol_HeaderActive = ImGuiCol_.ImGuiCol_HeaderActive; +alias ImGuiCol_Separator = ImGuiCol_.ImGuiCol_Separator; +alias ImGuiCol_SeparatorHovered = ImGuiCol_.ImGuiCol_SeparatorHovered; +alias ImGuiCol_SeparatorActive = ImGuiCol_.ImGuiCol_SeparatorActive; +alias ImGuiCol_ResizeGrip = ImGuiCol_.ImGuiCol_ResizeGrip; +alias ImGuiCol_ResizeGripHovered = ImGuiCol_.ImGuiCol_ResizeGripHovered; +alias ImGuiCol_ResizeGripActive = ImGuiCol_.ImGuiCol_ResizeGripActive; +alias ImGuiCol_Tab = ImGuiCol_.ImGuiCol_Tab; +alias ImGuiCol_TabHovered = ImGuiCol_.ImGuiCol_TabHovered; +alias ImGuiCol_TabActive = ImGuiCol_.ImGuiCol_TabActive; +alias ImGuiCol_TabUnfocused = ImGuiCol_.ImGuiCol_TabUnfocused; +alias ImGuiCol_TabUnfocusedActive = ImGuiCol_.ImGuiCol_TabUnfocusedActive; +alias ImGuiCol_PlotLines = ImGuiCol_.ImGuiCol_PlotLines; +alias ImGuiCol_PlotLinesHovered = ImGuiCol_.ImGuiCol_PlotLinesHovered; +alias ImGuiCol_PlotHistogram = ImGuiCol_.ImGuiCol_PlotHistogram; +alias ImGuiCol_PlotHistogramHovered = ImGuiCol_.ImGuiCol_PlotHistogramHovered; +alias ImGuiCol_TextSelectedBg = ImGuiCol_.ImGuiCol_TextSelectedBg; +alias ImGuiCol_DragDropTarget = ImGuiCol_.ImGuiCol_DragDropTarget; +alias ImGuiCol_NavHighlight = ImGuiCol_.ImGuiCol_NavHighlight; +alias ImGuiCol_NavWindowingHighlight = ImGuiCol_.ImGuiCol_NavWindowingHighlight; +alias ImGuiCol_NavWindowingDimBg = ImGuiCol_.ImGuiCol_NavWindowingDimBg; +alias ImGuiCol_ModalWindowDimBg = ImGuiCol_.ImGuiCol_ModalWindowDimBg; +alias ImGuiCol_COUNT = ImGuiCol_.ImGuiCol_COUNT; + +enum ImGuiStyleVar_ +{ + ImGuiStyleVar_Alpha = 0, + ImGuiStyleVar_WindowPadding = 1, + ImGuiStyleVar_WindowRounding = 2, + ImGuiStyleVar_WindowBorderSize = 3, + ImGuiStyleVar_WindowMinSize = 4, + ImGuiStyleVar_WindowTitleAlign = 5, + ImGuiStyleVar_ChildRounding = 6, + ImGuiStyleVar_ChildBorderSize = 7, + ImGuiStyleVar_PopupRounding = 8, + ImGuiStyleVar_PopupBorderSize = 9, + ImGuiStyleVar_FramePadding = 10, + ImGuiStyleVar_FrameRounding = 11, + ImGuiStyleVar_FrameBorderSize = 12, + ImGuiStyleVar_ItemSpacing = 13, + ImGuiStyleVar_ItemInnerSpacing = 14, + ImGuiStyleVar_IndentSpacing = 15, + ImGuiStyleVar_ScrollbarSize = 16, + ImGuiStyleVar_ScrollbarRounding = 17, + ImGuiStyleVar_GrabMinSize = 18, + ImGuiStyleVar_GrabRounding = 19, + ImGuiStyleVar_TabRounding = 20, + ImGuiStyleVar_ButtonTextAlign = 21, + ImGuiStyleVar_SelectableTextAlign = 22, + ImGuiStyleVar_COUNT = 23 +} + +alias ImGuiStyleVar_Alpha = ImGuiStyleVar_.ImGuiStyleVar_Alpha; +alias ImGuiStyleVar_WindowPadding = ImGuiStyleVar_.ImGuiStyleVar_WindowPadding; +alias ImGuiStyleVar_WindowRounding = ImGuiStyleVar_.ImGuiStyleVar_WindowRounding; +alias ImGuiStyleVar_WindowBorderSize = ImGuiStyleVar_.ImGuiStyleVar_WindowBorderSize; +alias ImGuiStyleVar_WindowMinSize = ImGuiStyleVar_.ImGuiStyleVar_WindowMinSize; +alias ImGuiStyleVar_WindowTitleAlign = ImGuiStyleVar_.ImGuiStyleVar_WindowTitleAlign; +alias ImGuiStyleVar_ChildRounding = ImGuiStyleVar_.ImGuiStyleVar_ChildRounding; +alias ImGuiStyleVar_ChildBorderSize = ImGuiStyleVar_.ImGuiStyleVar_ChildBorderSize; +alias ImGuiStyleVar_PopupRounding = ImGuiStyleVar_.ImGuiStyleVar_PopupRounding; +alias ImGuiStyleVar_PopupBorderSize = ImGuiStyleVar_.ImGuiStyleVar_PopupBorderSize; +alias ImGuiStyleVar_FramePadding = ImGuiStyleVar_.ImGuiStyleVar_FramePadding; +alias ImGuiStyleVar_FrameRounding = ImGuiStyleVar_.ImGuiStyleVar_FrameRounding; +alias ImGuiStyleVar_FrameBorderSize = ImGuiStyleVar_.ImGuiStyleVar_FrameBorderSize; +alias ImGuiStyleVar_ItemSpacing = ImGuiStyleVar_.ImGuiStyleVar_ItemSpacing; +alias ImGuiStyleVar_ItemInnerSpacing = ImGuiStyleVar_.ImGuiStyleVar_ItemInnerSpacing; +alias ImGuiStyleVar_IndentSpacing = ImGuiStyleVar_.ImGuiStyleVar_IndentSpacing; +alias ImGuiStyleVar_ScrollbarSize = ImGuiStyleVar_.ImGuiStyleVar_ScrollbarSize; +alias ImGuiStyleVar_ScrollbarRounding = ImGuiStyleVar_.ImGuiStyleVar_ScrollbarRounding; +alias ImGuiStyleVar_GrabMinSize = ImGuiStyleVar_.ImGuiStyleVar_GrabMinSize; +alias ImGuiStyleVar_GrabRounding = ImGuiStyleVar_.ImGuiStyleVar_GrabRounding; +alias ImGuiStyleVar_TabRounding = ImGuiStyleVar_.ImGuiStyleVar_TabRounding; +alias ImGuiStyleVar_ButtonTextAlign = ImGuiStyleVar_.ImGuiStyleVar_ButtonTextAlign; +alias ImGuiStyleVar_SelectableTextAlign = ImGuiStyleVar_.ImGuiStyleVar_SelectableTextAlign; +alias ImGuiStyleVar_COUNT = ImGuiStyleVar_.ImGuiStyleVar_COUNT; + +enum ImGuiColorEditFlags_ +{ + ImGuiColorEditFlags_None = 0, + ImGuiColorEditFlags_NoAlpha = 1 << 1, + ImGuiColorEditFlags_NoPicker = 1 << 2, + ImGuiColorEditFlags_NoOptions = 1 << 3, + ImGuiColorEditFlags_NoSmallPreview = 1 << 4, + ImGuiColorEditFlags_NoInputs = 1 << 5, + ImGuiColorEditFlags_NoTooltip = 1 << 6, + ImGuiColorEditFlags_NoLabel = 1 << 7, + ImGuiColorEditFlags_NoSidePreview = 1 << 8, + ImGuiColorEditFlags_NoDragDrop = 1 << 9, + ImGuiColorEditFlags_AlphaBar = 1 << 16, + ImGuiColorEditFlags_AlphaPreview = 1 << 17, + ImGuiColorEditFlags_AlphaPreviewHalf = 1 << 18, + ImGuiColorEditFlags_HDR = 1 << 19, + ImGuiColorEditFlags_DisplayRGB = 1 << 20, + ImGuiColorEditFlags_DisplayHSV = 1 << 21, + ImGuiColorEditFlags_DisplayHex = 1 << 22, + ImGuiColorEditFlags_Uint8 = 1 << 23, + ImGuiColorEditFlags_Float = 1 << 24, + ImGuiColorEditFlags_PickerHueBar = 1 << 25, + ImGuiColorEditFlags_PickerHueWheel = 1 << 26, + ImGuiColorEditFlags_InputRGB = 1 << 27, + ImGuiColorEditFlags_InputHSV = 1 << 28, + ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_PickerHueBar, + ImGuiColorEditFlags__DisplayMask = ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_DisplayHSV | ImGuiColorEditFlags_DisplayHex, + ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_Uint8 | ImGuiColorEditFlags_Float, + ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_PickerHueWheel | ImGuiColorEditFlags_PickerHueBar, + ImGuiColorEditFlags__InputMask = ImGuiColorEditFlags_InputRGB | ImGuiColorEditFlags_InputHSV +} + +alias ImGuiColorEditFlags_None = ImGuiColorEditFlags_.ImGuiColorEditFlags_None; +alias ImGuiColorEditFlags_NoAlpha = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoAlpha; +alias ImGuiColorEditFlags_NoPicker = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoPicker; +alias ImGuiColorEditFlags_NoOptions = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoOptions; +alias ImGuiColorEditFlags_NoSmallPreview = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoSmallPreview; +alias ImGuiColorEditFlags_NoInputs = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoInputs; +alias ImGuiColorEditFlags_NoTooltip = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoTooltip; +alias ImGuiColorEditFlags_NoLabel = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoLabel; +alias ImGuiColorEditFlags_NoSidePreview = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoSidePreview; +alias ImGuiColorEditFlags_NoDragDrop = ImGuiColorEditFlags_.ImGuiColorEditFlags_NoDragDrop; +alias ImGuiColorEditFlags_AlphaBar = ImGuiColorEditFlags_.ImGuiColorEditFlags_AlphaBar; +alias ImGuiColorEditFlags_AlphaPreview = ImGuiColorEditFlags_.ImGuiColorEditFlags_AlphaPreview; +alias ImGuiColorEditFlags_AlphaPreviewHalf = ImGuiColorEditFlags_.ImGuiColorEditFlags_AlphaPreviewHalf; +alias ImGuiColorEditFlags_HDR = ImGuiColorEditFlags_.ImGuiColorEditFlags_HDR; +alias ImGuiColorEditFlags_DisplayRGB = ImGuiColorEditFlags_.ImGuiColorEditFlags_DisplayRGB; +alias ImGuiColorEditFlags_DisplayHSV = ImGuiColorEditFlags_.ImGuiColorEditFlags_DisplayHSV; +alias ImGuiColorEditFlags_DisplayHex = ImGuiColorEditFlags_.ImGuiColorEditFlags_DisplayHex; +alias ImGuiColorEditFlags_Uint8 = ImGuiColorEditFlags_.ImGuiColorEditFlags_Uint8; +alias ImGuiColorEditFlags_Float = ImGuiColorEditFlags_.ImGuiColorEditFlags_Float; +alias ImGuiColorEditFlags_PickerHueBar = ImGuiColorEditFlags_.ImGuiColorEditFlags_PickerHueBar; +alias ImGuiColorEditFlags_PickerHueWheel = ImGuiColorEditFlags_.ImGuiColorEditFlags_PickerHueWheel; +alias ImGuiColorEditFlags_InputRGB = ImGuiColorEditFlags_.ImGuiColorEditFlags_InputRGB; +alias ImGuiColorEditFlags_InputHSV = ImGuiColorEditFlags_.ImGuiColorEditFlags_InputHSV; +alias ImGuiColorEditFlags__OptionsDefault = ImGuiColorEditFlags_.ImGuiColorEditFlags__OptionsDefault; +alias ImGuiColorEditFlags__DisplayMask = ImGuiColorEditFlags_.ImGuiColorEditFlags__DisplayMask; +alias ImGuiColorEditFlags__DataTypeMask = ImGuiColorEditFlags_.ImGuiColorEditFlags__DataTypeMask; +alias ImGuiColorEditFlags__PickerMask = ImGuiColorEditFlags_.ImGuiColorEditFlags__PickerMask; +alias ImGuiColorEditFlags__InputMask = ImGuiColorEditFlags_.ImGuiColorEditFlags__InputMask; + +enum ImGuiMouseCursor_ +{ + ImGuiMouseCursor_None = -1, + ImGuiMouseCursor_Arrow = 0, + ImGuiMouseCursor_TextInput = 1, + ImGuiMouseCursor_ResizeAll = 2, + ImGuiMouseCursor_ResizeNS = 3, + ImGuiMouseCursor_ResizeEW = 4, + ImGuiMouseCursor_ResizeNESW = 5, + ImGuiMouseCursor_ResizeNWSE = 6, + ImGuiMouseCursor_Hand = 7, + ImGuiMouseCursor_COUNT = 8 +} + +alias ImGuiMouseCursor_None = ImGuiMouseCursor_.ImGuiMouseCursor_None; +alias ImGuiMouseCursor_Arrow = ImGuiMouseCursor_.ImGuiMouseCursor_Arrow; +alias ImGuiMouseCursor_TextInput = ImGuiMouseCursor_.ImGuiMouseCursor_TextInput; +alias ImGuiMouseCursor_ResizeAll = ImGuiMouseCursor_.ImGuiMouseCursor_ResizeAll; +alias ImGuiMouseCursor_ResizeNS = ImGuiMouseCursor_.ImGuiMouseCursor_ResizeNS; +alias ImGuiMouseCursor_ResizeEW = ImGuiMouseCursor_.ImGuiMouseCursor_ResizeEW; +alias ImGuiMouseCursor_ResizeNESW = ImGuiMouseCursor_.ImGuiMouseCursor_ResizeNESW; +alias ImGuiMouseCursor_ResizeNWSE = ImGuiMouseCursor_.ImGuiMouseCursor_ResizeNWSE; +alias ImGuiMouseCursor_Hand = ImGuiMouseCursor_.ImGuiMouseCursor_Hand; +alias ImGuiMouseCursor_COUNT = ImGuiMouseCursor_.ImGuiMouseCursor_COUNT; + +enum ImGuiCond_ +{ + ImGuiCond_Always = 1 << 0, + ImGuiCond_Once = 1 << 1, + ImGuiCond_FirstUseEver = 1 << 2, + ImGuiCond_Appearing = 1 << 3 +} + +alias ImGuiCond_Always = ImGuiCond_.ImGuiCond_Always; +alias ImGuiCond_Once = ImGuiCond_.ImGuiCond_Once; +alias ImGuiCond_FirstUseEver = ImGuiCond_.ImGuiCond_FirstUseEver; +alias ImGuiCond_Appearing = ImGuiCond_.ImGuiCond_Appearing; + +struct ImGuiStyle +{ + float Alpha; + ImVec2 WindowPadding; + float WindowRounding; + float WindowBorderSize; + ImVec2 WindowMinSize; + ImVec2 WindowTitleAlign; + ImGuiDir WindowMenuButtonPosition; + float ChildRounding; + float ChildBorderSize; + float PopupRounding; + float PopupBorderSize; + ImVec2 FramePadding; + float FrameRounding; + float FrameBorderSize; + ImVec2 ItemSpacing; + ImVec2 ItemInnerSpacing; + ImVec2 TouchExtraPadding; + float IndentSpacing; + float ColumnsMinSpacing; + float ScrollbarSize; + float ScrollbarRounding; + float GrabMinSize; + float GrabRounding; + float TabRounding; + float TabBorderSize; + ImGuiDir ColorButtonPosition; + ImVec2 ButtonTextAlign; + ImVec2 SelectableTextAlign; + ImVec2 DisplayWindowPadding; + ImVec2 DisplaySafeAreaPadding; + float MouseCursorScale; + bool AntiAliasedLines; + bool AntiAliasedFill; + float CurveTessellationTol; + ImVec4[ImGuiCol_COUNT] Colors; +} + +struct ImGuiIO +{ + ImGuiConfigFlags ConfigFlags; + ImGuiBackendFlags BackendFlags; + ImVec2 DisplaySize; + float DeltaTime; + float IniSavingRate; + const(char)* IniFilename; + const(char)* LogFilename; + float MouseDoubleClickTime; + float MouseDoubleClickMaxDist; + float MouseDragThreshold; + int[ImGuiKey_COUNT] KeyMap; + float KeyRepeatDelay; + float KeyRepeatRate; + void* UserData; + ImFontAtlas* Fonts; + float FontGlobalScale; + bool FontAllowUserScaling; + ImFont* FontDefault; + ImVec2 DisplayFramebufferScale; + bool MouseDrawCursor; + bool ConfigMacOSXBehaviors; + bool ConfigInputTextCursorBlink; + bool ConfigWindowsResizeFromEdges; + bool ConfigWindowsMoveFromTitleBarOnly; + float ConfigWindowsMemoryCompactTimer; + const(char)* BackendPlatformName; + const(char)* BackendRendererName; + void* BackendPlatformUserData; + void* BackendRendererUserData; + void* BackendLanguageUserData; + const(char)* function (void* user_data) GetClipboardTextFn; + void function (void* user_data, const(char)* text) SetClipboardTextFn; + void* ClipboardUserData; + void function (int x, int y) ImeSetInputScreenPosFn; + void* ImeWindowHandle; + void* RenderDrawListsFnUnused; + ImVec2 MousePos; + bool[5] MouseDown; + float MouseWheel; + float MouseWheelH; + bool KeyCtrl; + bool KeyShift; + bool KeyAlt; + bool KeySuper; + bool[512] KeysDown; + float[ImGuiNavInput_COUNT] NavInputs; + bool WantCaptureMouse; + bool WantCaptureKeyboard; + bool WantTextInput; + bool WantSetMousePos; + bool WantSaveIniSettings; + bool NavActive; + bool NavVisible; + float Framerate; + int MetricsRenderVertices; + int MetricsRenderIndices; + int MetricsRenderWindows; + int MetricsActiveWindows; + int MetricsActiveAllocations; + ImVec2 MouseDelta; + ImVec2 MousePosPrev; + ImVec2[5] MouseClickedPos; + double[5] MouseClickedTime; + bool[5] MouseClicked; + bool[5] MouseDoubleClicked; + bool[5] MouseReleased; + bool[5] MouseDownOwned; + bool[5] MouseDownWasDoubleClick; + float[5] MouseDownDuration; + float[5] MouseDownDurationPrev; + ImVec2[5] MouseDragMaxDistanceAbs; + float[5] MouseDragMaxDistanceSqr; + float[512] KeysDownDuration; + float[512] KeysDownDurationPrev; + float[ImGuiNavInput_COUNT] NavInputsDownDuration; + float[ImGuiNavInput_COUNT] NavInputsDownDurationPrev; + ImVector_ImWchar InputQueueCharacters; +} + +struct ImGuiInputTextCallbackData +{ + ImGuiInputTextFlags EventFlag; + ImGuiInputTextFlags Flags; + void* UserData; + ImWchar EventChar; + ImGuiKey EventKey; + char* Buf; + int BufTextLen; + int BufSize; + bool BufDirty; + int CursorPos; + int SelectionStart; + int SelectionEnd; +} + +struct ImGuiSizeCallbackData +{ + void* UserData; + ImVec2 Pos; + ImVec2 CurrentSize; + ImVec2 DesiredSize; +} + +struct ImGuiPayload +{ + void* Data; + int DataSize; + ImGuiID SourceId; + ImGuiID SourceParentId; + int DataFrameCount; + char[33] DataType; + bool Preview; + bool Delivery; +} + +struct ImGuiOnceUponAFrame +{ + int RefFrame; +} + +struct ImGuiTextFilter +{ + char[256] InputBuf; + ImVector_ImGuiTextRange Filters; + int CountGrep; +} + +struct ImGuiTextBuffer +{ + ImVector_char Buf; +} + +struct ImGuiStorage +{ + ImVector_ImGuiStoragePair Data; +} + +struct ImGuiListClipper +{ + float StartPosY; + float ItemsHeight; + int ItemsCount; + int StepNo; + int DisplayStart; + int DisplayEnd; +} + +struct ImColor +{ + ImVec4 Value; +} + +struct ImDrawCmd +{ + uint ElemCount; + ImVec4 ClipRect; + ImTextureID TextureId; + uint VtxOffset; + uint IdxOffset; + ImDrawCallback UserCallback; + void* UserCallbackData; +} + +struct ImDrawVert +{ + ImVec2 pos; + ImVec2 uv; + ImU32 col; +} + +struct ImDrawChannel +{ + ImVector_ImDrawCmd _CmdBuffer; + ImVector_ImDrawIdx _IdxBuffer; +} + +struct ImDrawListSplitter +{ + int _Current; + int _Count; + ImVector_ImDrawChannel _Channels; +} + +enum ImDrawCornerFlags_ +{ + ImDrawCornerFlags_None = 0, + ImDrawCornerFlags_TopLeft = 1 << 0, + ImDrawCornerFlags_TopRight = 1 << 1, + ImDrawCornerFlags_BotLeft = 1 << 2, + ImDrawCornerFlags_BotRight = 1 << 3, + ImDrawCornerFlags_Top = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_TopRight, + ImDrawCornerFlags_Bot = ImDrawCornerFlags_BotLeft | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_Left = ImDrawCornerFlags_TopLeft | ImDrawCornerFlags_BotLeft, + ImDrawCornerFlags_Right = ImDrawCornerFlags_TopRight | ImDrawCornerFlags_BotRight, + ImDrawCornerFlags_All = 0xF +} + +alias ImDrawCornerFlags_None = ImDrawCornerFlags_.ImDrawCornerFlags_None; +alias ImDrawCornerFlags_TopLeft = ImDrawCornerFlags_.ImDrawCornerFlags_TopLeft; +alias ImDrawCornerFlags_TopRight = ImDrawCornerFlags_.ImDrawCornerFlags_TopRight; +alias ImDrawCornerFlags_BotLeft = ImDrawCornerFlags_.ImDrawCornerFlags_BotLeft; +alias ImDrawCornerFlags_BotRight = ImDrawCornerFlags_.ImDrawCornerFlags_BotRight; +alias ImDrawCornerFlags_Top = ImDrawCornerFlags_.ImDrawCornerFlags_Top; +alias ImDrawCornerFlags_Bot = ImDrawCornerFlags_.ImDrawCornerFlags_Bot; +alias ImDrawCornerFlags_Left = ImDrawCornerFlags_.ImDrawCornerFlags_Left; +alias ImDrawCornerFlags_Right = ImDrawCornerFlags_.ImDrawCornerFlags_Right; +alias ImDrawCornerFlags_All = ImDrawCornerFlags_.ImDrawCornerFlags_All; + +enum ImDrawListFlags_ +{ + ImDrawListFlags_None = 0, + ImDrawListFlags_AntiAliasedLines = 1 << 0, + ImDrawListFlags_AntiAliasedFill = 1 << 1, + ImDrawListFlags_AllowVtxOffset = 1 << 2 +} + +alias ImDrawListFlags_None = ImDrawListFlags_.ImDrawListFlags_None; +alias ImDrawListFlags_AntiAliasedLines = ImDrawListFlags_.ImDrawListFlags_AntiAliasedLines; +alias ImDrawListFlags_AntiAliasedFill = ImDrawListFlags_.ImDrawListFlags_AntiAliasedFill; +alias ImDrawListFlags_AllowVtxOffset = ImDrawListFlags_.ImDrawListFlags_AllowVtxOffset; + +struct ImDrawList +{ + ImVector_ImDrawCmd CmdBuffer; + ImVector_ImDrawIdx IdxBuffer; + ImVector_ImDrawVert VtxBuffer; + ImDrawListFlags Flags; + const(ImDrawListSharedData)* _Data; + const(char)* _OwnerName; + uint _VtxCurrentOffset; + uint _VtxCurrentIdx; + ImDrawVert* _VtxWritePtr; + ImDrawIdx* _IdxWritePtr; + ImVector_ImVec4 _ClipRectStack; + ImVector_ImTextureID _TextureIdStack; + ImVector_ImVec2 _Path; + ImDrawListSplitter _Splitter; +} + +struct ImDrawData +{ + bool Valid; + ImDrawList** CmdLists; + int CmdListsCount; + int TotalIdxCount; + int TotalVtxCount; + ImVec2 DisplayPos; + ImVec2 DisplaySize; + ImVec2 FramebufferScale; +} + +struct ImFontConfig +{ + void* FontData; + int FontDataSize; + bool FontDataOwnedByAtlas; + int FontNo; + float SizePixels; + int OversampleH; + int OversampleV; + bool PixelSnapH; + ImVec2 GlyphExtraSpacing; + ImVec2 GlyphOffset; + const(ImWchar)* GlyphRanges; + float GlyphMinAdvanceX; + float GlyphMaxAdvanceX; + bool MergeMode; + uint RasterizerFlags; + float RasterizerMultiply; + ImWchar EllipsisChar; + char[40] Name; + ImFont* DstFont; +} + +struct ImFontGlyph +{ + ImWchar Codepoint; + float AdvanceX; + float X0; + float Y0; + float X1; + float Y1; + float U0; + float V0; + float U1; + float V1; +} + +struct ImFontGlyphRangesBuilder +{ + ImVector_ImU32 UsedChars; +} + +struct ImFontAtlasCustomRect +{ + uint ID; + ushort Width; + ushort Height; + ushort X; + ushort Y; + float GlyphAdvanceX; + ImVec2 GlyphOffset; + ImFont* Font; +} + +enum ImFontAtlasFlags_ +{ + ImFontAtlasFlags_None = 0, + ImFontAtlasFlags_NoPowerOfTwoHeight = 1 << 0, + ImFontAtlasFlags_NoMouseCursors = 1 << 1 +} + +alias ImFontAtlasFlags_None = ImFontAtlasFlags_.ImFontAtlasFlags_None; +alias ImFontAtlasFlags_NoPowerOfTwoHeight = ImFontAtlasFlags_.ImFontAtlasFlags_NoPowerOfTwoHeight; +alias ImFontAtlasFlags_NoMouseCursors = ImFontAtlasFlags_.ImFontAtlasFlags_NoMouseCursors; + +struct ImFontAtlas +{ + bool Locked; + ImFontAtlasFlags Flags; + ImTextureID TexID; + int TexDesiredWidth; + int TexGlyphPadding; + ubyte* TexPixelsAlpha8; + uint* TexPixelsRGBA32; + int TexWidth; + int TexHeight; + ImVec2 TexUvScale; + ImVec2 TexUvWhitePixel; + ImVector_ImFontPtr Fonts; + ImVector_ImFontAtlasCustomRect CustomRects; + ImVector_ImFontConfig ConfigData; + int[1] CustomRectIds; +} + +struct ImFont +{ + ImVector_float IndexAdvanceX; + float FallbackAdvanceX; + float FontSize; + ImVector_ImWchar IndexLookup; + ImVector_ImFontGlyph Glyphs; + const(ImFontGlyph)* FallbackGlyph; + ImVec2 DisplayOffset; + ImFontAtlas* ContainerAtlas; + const(ImFontConfig)* ConfigData; + short ConfigDataCount; + ImWchar FallbackChar; + ImWchar EllipsisChar; + float Scale; + float Ascent; + float Descent; + int MetricsTotalSurface; + bool DirtyLookupTables; +} + +struct ImGuiTextRange +{ + const(char)* b; + const(char)* e; +} + +struct ImGuiStoragePair +{ + ImGuiID key; + + union + { + int val_i; + float val_f; + void* val_p; + } +} + +// CIMGUI_DEFINE_ENUMS_AND_STRUCTS + +//CIMGUI_DEFINE_ENUMS_AND_STRUCTS +ImVec2* ImVec2_ImVec2 (); +void ImVec2_destroy (ImVec2* self); +ImVec2* ImVec2_ImVec2Float (float _x, float _y); +ImVec4* ImVec4_ImVec4 (); +void ImVec4_destroy (ImVec4* self); +ImVec4* ImVec4_ImVec4Float (float _x, float _y, float _z, float _w); +ImGuiContext* igCreateContext (ImFontAtlas* shared_font_atlas); +void igDestroyContext (ImGuiContext* ctx); +ImGuiContext* igGetCurrentContext (); +void igSetCurrentContext (ImGuiContext* ctx); +bool igDebugCheckVersionAndDataLayout (const(char)* version_str, size_t sz_io, size_t sz_style, size_t sz_vec2, size_t sz_vec4, size_t sz_drawvert, size_t sz_drawidx); +ImGuiIO* igGetIO (); +ImGuiStyle* igGetStyle (); +void igNewFrame (); +void igEndFrame (); +void igRender (); +ImDrawData* igGetDrawData (); +void igShowDemoWindow (bool* p_open); +void igShowAboutWindow (bool* p_open); +void igShowMetricsWindow (bool* p_open); +void igShowStyleEditor (ImGuiStyle* ref_); +bool igShowStyleSelector (const(char)* label); +void igShowFontSelector (const(char)* label); +void igShowUserGuide (); +const(char)* igGetVersion (); +void igStyleColorsDark (ImGuiStyle* dst); +void igStyleColorsClassic (ImGuiStyle* dst); +void igStyleColorsLight (ImGuiStyle* dst); +bool igBegin (const(char)* name, bool* p_open, ImGuiWindowFlags flags); +void igEnd (); +bool igBeginChild (const(char)* str_id, const ImVec2 size, bool border, ImGuiWindowFlags flags); +bool igBeginChildID (ImGuiID id, const ImVec2 size, bool border, ImGuiWindowFlags flags); +void igEndChild (); +bool igIsWindowAppearing (); +bool igIsWindowCollapsed (); +bool igIsWindowFocused (ImGuiFocusedFlags flags); +bool igIsWindowHovered (ImGuiHoveredFlags flags); +ImDrawList* igGetWindowDrawList (); +ImVec2 igGetWindowPos (); +ImVec2 igGetWindowSize (); +float igGetWindowWidth (); +float igGetWindowHeight (); +void igSetNextWindowPos (const ImVec2 pos, ImGuiCond cond, const ImVec2 pivot); +void igSetNextWindowSize (const ImVec2 size, ImGuiCond cond); +void igSetNextWindowSizeConstraints (const ImVec2 size_min, const ImVec2 size_max, ImGuiSizeCallback custom_callback, void* custom_callback_data); +void igSetNextWindowContentSize (const ImVec2 size); +void igSetNextWindowCollapsed (bool collapsed, ImGuiCond cond); +void igSetNextWindowFocus (); +void igSetNextWindowBgAlpha (float alpha); +void igSetWindowPosVec2 (const ImVec2 pos, ImGuiCond cond); +void igSetWindowSizeVec2 (const ImVec2 size, ImGuiCond cond); +void igSetWindowCollapsedBool (bool collapsed, ImGuiCond cond); +void igSetWindowFocus (); +void igSetWindowFontScale (float scale); +void igSetWindowPosStr (const(char)* name, const ImVec2 pos, ImGuiCond cond); +void igSetWindowSizeStr (const(char)* name, const ImVec2 size, ImGuiCond cond); +void igSetWindowCollapsedStr (const(char)* name, bool collapsed, ImGuiCond cond); +void igSetWindowFocusStr (const(char)* name); +ImVec2 igGetContentRegionMax (); +ImVec2 igGetContentRegionAvail (); +ImVec2 igGetWindowContentRegionMin (); +ImVec2 igGetWindowContentRegionMax (); +float igGetWindowContentRegionWidth (); +float igGetScrollX (); +float igGetScrollY (); +float igGetScrollMaxX (); +float igGetScrollMaxY (); +void igSetScrollX (float scroll_x); +void igSetScrollY (float scroll_y); +void igSetScrollHereX (float center_x_ratio); +void igSetScrollHereY (float center_y_ratio); +void igSetScrollFromPosX (float local_x, float center_x_ratio); +void igSetScrollFromPosY (float local_y, float center_y_ratio); +void igPushFont (ImFont* font); +void igPopFont (); +void igPushStyleColorU32 (ImGuiCol idx, ImU32 col); +void igPushStyleColor (ImGuiCol idx, const ImVec4 col); +void igPopStyleColor (int count); +void igPushStyleVarFloat (ImGuiStyleVar idx, float val); +void igPushStyleVarVec2 (ImGuiStyleVar idx, const ImVec2 val); +void igPopStyleVar (int count); +const(ImVec4)* igGetStyleColorVec4 (ImGuiCol idx); +ImFont* igGetFont (); +float igGetFontSize (); +ImVec2 igGetFontTexUvWhitePixel (); +ImU32 igGetColorU32 (ImGuiCol idx, float alpha_mul); +ImU32 igGetColorU32Vec4 (const ImVec4 col); +ImU32 igGetColorU32U32 (ImU32 col); +void igPushItemWidth (float item_width); +void igPopItemWidth (); +void igSetNextItemWidth (float item_width); +float igCalcItemWidth (); +void igPushTextWrapPos (float wrap_local_pos_x); +void igPopTextWrapPos (); +void igPushAllowKeyboardFocus (bool allow_keyboard_focus); +void igPopAllowKeyboardFocus (); +void igPushButtonRepeat (bool repeat); +void igPopButtonRepeat (); +void igSeparator (); +void igSameLine (float offset_from_start_x, float spacing); +void igNewLine (); +void igSpacing (); +void igDummy (const ImVec2 size); +void igIndent (float indent_w); +void igUnindent (float indent_w); +void igBeginGroup (); +void igEndGroup (); +ImVec2 igGetCursorPos (); +float igGetCursorPosX (); +float igGetCursorPosY (); +void igSetCursorPos (const ImVec2 local_pos); +void igSetCursorPosX (float local_x); +void igSetCursorPosY (float local_y); +ImVec2 igGetCursorStartPos (); +ImVec2 igGetCursorScreenPos (); +void igSetCursorScreenPos (const ImVec2 pos); +void igAlignTextToFramePadding (); +float igGetTextLineHeight (); +float igGetTextLineHeightWithSpacing (); +float igGetFrameHeight (); +float igGetFrameHeightWithSpacing (); +void igPushIDStr (const(char)* str_id); +void igPushIDRange (const(char)* str_id_begin, const(char)* str_id_end); +void igPushIDPtr (const(void)* ptr_id); +void igPushIDInt (int int_id); +void igPopID (); +ImGuiID igGetIDStr (const(char)* str_id); +ImGuiID igGetIDRange (const(char)* str_id_begin, const(char)* str_id_end); +ImGuiID igGetIDPtr (const(void)* ptr_id); +void igTextUnformatted (const(char)* text, const(char)* text_end); +void igText (const(char)* fmt, ...); +void igTextV (const(char)* fmt, va_list args); +void igTextColored (const ImVec4 col, const(char)* fmt, ...); +void igTextColoredV (const ImVec4 col, const(char)* fmt, va_list args); +void igTextDisabled (const(char)* fmt, ...); +void igTextDisabledV (const(char)* fmt, va_list args); +void igTextWrapped (const(char)* fmt, ...); +void igTextWrappedV (const(char)* fmt, va_list args); +void igLabelText (const(char)* label, const(char)* fmt, ...); +void igLabelTextV (const(char)* label, const(char)* fmt, va_list args); +void igBulletText (const(char)* fmt, ...); +void igBulletTextV (const(char)* fmt, va_list args); +bool igButton (const(char)* label, const ImVec2 size); +bool igSmallButton (const(char)* label); +bool igInvisibleButton (const(char)* str_id, const ImVec2 size); +bool igArrowButton (const(char)* str_id, ImGuiDir dir); +void igImage (ImTextureID user_texture_id, const ImVec2 size, const ImVec2 uv0, const ImVec2 uv1, const ImVec4 tint_col, const ImVec4 border_col); +bool igImageButton (ImTextureID user_texture_id, const ImVec2 size, const ImVec2 uv0, const ImVec2 uv1, int frame_padding, const ImVec4 bg_col, const ImVec4 tint_col); +bool igCheckbox (const(char)* label, bool* v); +bool igCheckboxFlags (const(char)* label, uint* flags, uint flags_value); +bool igRadioButtonBool (const(char)* label, bool active); +bool igRadioButtonIntPtr (const(char)* label, int* v, int v_button); +void igProgressBar (float fraction, const ImVec2 size_arg, const(char)* overlay); +void igBullet (); +bool igBeginCombo (const(char)* label, const(char)* preview_value, ImGuiComboFlags flags); +void igEndCombo (); +bool igCombo (const(char)* label, int* current_item, const(char*)* items, int items_count, int popup_max_height_in_items); +bool igComboStr (const(char)* label, int* current_item, const(char)* items_separated_by_zeros, int popup_max_height_in_items); +bool igComboFnPtr (const(char)* label, int* current_item, bool function (void* data, int idx, const(char*)* out_text) items_getter, void* data, int items_count, int popup_max_height_in_items); +bool igDragFloat (const(char)* label, float* v, float v_speed, float v_min, float v_max, const(char)* format, float power); +bool igDragFloat2 (const(char)* label, ref float[2] v, float v_speed, float v_min, float v_max, const(char)* format, float power); +bool igDragFloat3 (const(char)* label, ref float[3] v, float v_speed, float v_min, float v_max, const(char)* format, float power); +bool igDragFloat4 (const(char)* label, ref float[4] v, float v_speed, float v_min, float v_max, const(char)* format, float power); +bool igDragFloatRange2 (const(char)* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, const(char)* format, const(char)* format_max, float power); +bool igDragInt (const(char)* label, int* v, float v_speed, int v_min, int v_max, const(char)* format); +bool igDragInt2 (const(char)* label, ref int[2] v, float v_speed, int v_min, int v_max, const(char)* format); +bool igDragInt3 (const(char)* label, ref int[3] v, float v_speed, int v_min, int v_max, const(char)* format); +bool igDragInt4 (const(char)* label, ref int[4] v, float v_speed, int v_min, int v_max, const(char)* format); +bool igDragIntRange2 (const(char)* label, int* v_current_min, int* v_current_max, float v_speed, int v_min, int v_max, const(char)* format, const(char)* format_max); +bool igDragScalar (const(char)* label, ImGuiDataType data_type, void* v, float v_speed, const(void)* v_min, const(void)* v_max, const(char)* format, float power); +bool igDragScalarN (const(char)* label, ImGuiDataType data_type, void* v, int components, float v_speed, const(void)* v_min, const(void)* v_max, const(char)* format, float power); +bool igSliderFloat (const(char)* label, float* v, float v_min, float v_max, const(char)* format, float power); +bool igSliderFloat2 (const(char)* label, ref float[2] v, float v_min, float v_max, const(char)* format, float power); +bool igSliderFloat3 (const(char)* label, ref float[3] v, float v_min, float v_max, const(char)* format, float power); +bool igSliderFloat4 (const(char)* label, ref float[4] v, float v_min, float v_max, const(char)* format, float power); +bool igSliderAngle (const(char)* label, float* v_rad, float v_degrees_min, float v_degrees_max, const(char)* format); +bool igSliderInt (const(char)* label, int* v, int v_min, int v_max, const(char)* format); +bool igSliderInt2 (const(char)* label, ref int[2] v, int v_min, int v_max, const(char)* format); +bool igSliderInt3 (const(char)* label, ref int[3] v, int v_min, int v_max, const(char)* format); +bool igSliderInt4 (const(char)* label, ref int[4] v, int v_min, int v_max, const(char)* format); +bool igSliderScalar (const(char)* label, ImGuiDataType data_type, void* v, const(void)* v_min, const(void)* v_max, const(char)* format, float power); +bool igSliderScalarN (const(char)* label, ImGuiDataType data_type, void* v, int components, const(void)* v_min, const(void)* v_max, const(char)* format, float power); +bool igVSliderFloat (const(char)* label, const ImVec2 size, float* v, float v_min, float v_max, const(char)* format, float power); +bool igVSliderInt (const(char)* label, const ImVec2 size, int* v, int v_min, int v_max, const(char)* format); +bool igVSliderScalar (const(char)* label, const ImVec2 size, ImGuiDataType data_type, void* v, const(void)* v_min, const(void)* v_max, const(char)* format, float power); +bool igInputText (const(char)* label, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data); +bool igInputTextMultiline (const(char)* label, char* buf, size_t buf_size, const ImVec2 size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data); +bool igInputTextWithHint (const(char)* label, const(char)* hint, char* buf, size_t buf_size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data); +bool igInputFloat (const(char)* label, float* v, float step, float step_fast, const(char)* format, ImGuiInputTextFlags flags); +bool igInputFloat2 (const(char)* label, ref float[2] v, const(char)* format, ImGuiInputTextFlags flags); +bool igInputFloat3 (const(char)* label, ref float[3] v, const(char)* format, ImGuiInputTextFlags flags); +bool igInputFloat4 (const(char)* label, ref float[4] v, const(char)* format, ImGuiInputTextFlags flags); +bool igInputInt (const(char)* label, int* v, int step, int step_fast, ImGuiInputTextFlags flags); +bool igInputInt2 (const(char)* label, ref int[2] v, ImGuiInputTextFlags flags); +bool igInputInt3 (const(char)* label, ref int[3] v, ImGuiInputTextFlags flags); +bool igInputInt4 (const(char)* label, ref int[4] v, ImGuiInputTextFlags flags); +bool igInputDouble (const(char)* label, double* v, double step, double step_fast, const(char)* format, ImGuiInputTextFlags flags); +bool igInputScalar (const(char)* label, ImGuiDataType data_type, void* v, const(void)* step, const(void)* step_fast, const(char)* format, ImGuiInputTextFlags flags); +bool igInputScalarN (const(char)* label, ImGuiDataType data_type, void* v, int components, const(void)* step, const(void)* step_fast, const(char)* format, ImGuiInputTextFlags flags); +bool igColorEdit3 (const(char)* label, ref float[3] col, ImGuiColorEditFlags flags); +bool igColorEdit4 (const(char)* label, ref float[4] col, ImGuiColorEditFlags flags); +bool igColorPicker3 (const(char)* label, ref float[3] col, ImGuiColorEditFlags flags); +bool igColorPicker4 (const(char)* label, ref float[4] col, ImGuiColorEditFlags flags, const(float)* ref_col); +bool igColorButton (const(char)* desc_id, const ImVec4 col, ImGuiColorEditFlags flags, ImVec2 size); +void igSetColorEditOptions (ImGuiColorEditFlags flags); +bool igTreeNodeStr (const(char)* label); +bool igTreeNodeStrStr (const(char)* str_id, const(char)* fmt, ...); +bool igTreeNodePtr (const(void)* ptr_id, const(char)* fmt, ...); +bool igTreeNodeVStr (const(char)* str_id, const(char)* fmt, va_list args); +bool igTreeNodeVPtr (const(void)* ptr_id, const(char)* fmt, va_list args); +bool igTreeNodeExStr (const(char)* label, ImGuiTreeNodeFlags flags); +bool igTreeNodeExStrStr (const(char)* str_id, ImGuiTreeNodeFlags flags, const(char)* fmt, ...); +bool igTreeNodeExPtr (const(void)* ptr_id, ImGuiTreeNodeFlags flags, const(char)* fmt, ...); +bool igTreeNodeExVStr (const(char)* str_id, ImGuiTreeNodeFlags flags, const(char)* fmt, va_list args); +bool igTreeNodeExVPtr (const(void)* ptr_id, ImGuiTreeNodeFlags flags, const(char)* fmt, va_list args); +void igTreePushStr (const(char)* str_id); +void igTreePushPtr (const(void)* ptr_id); +void igTreePop (); +float igGetTreeNodeToLabelSpacing (); +bool igCollapsingHeader (const(char)* label, ImGuiTreeNodeFlags flags); +bool igCollapsingHeaderBoolPtr (const(char)* label, bool* p_open, ImGuiTreeNodeFlags flags); +void igSetNextItemOpen (bool is_open, ImGuiCond cond); +bool igSelectable (const(char)* label, bool selected, ImGuiSelectableFlags flags, const ImVec2 size); +bool igSelectableBoolPtr (const(char)* label, bool* p_selected, ImGuiSelectableFlags flags, const ImVec2 size); +bool igListBoxStr_arr (const(char)* label, int* current_item, const(char*)* items, int items_count, int height_in_items); +bool igListBoxFnPtr (const(char)* label, int* current_item, bool function (void* data, int idx, const(char*)* out_text) items_getter, void* data, int items_count, int height_in_items); +bool igListBoxHeaderVec2 (const(char)* label, const ImVec2 size); +bool igListBoxHeaderInt (const(char)* label, int items_count, int height_in_items); +void igListBoxFooter (); +void igPlotLines (const(char)* label, const(float)* values, int values_count, int values_offset, const(char)* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride); +void igPlotLinesFnPtr (const(char)* label, float function (void* data, int idx) values_getter, void* data, int values_count, int values_offset, const(char)* overlay_text, float scale_min, float scale_max, ImVec2 graph_size); +void igPlotHistogramFloatPtr (const(char)* label, const(float)* values, int values_count, int values_offset, const(char)* overlay_text, float scale_min, float scale_max, ImVec2 graph_size, int stride); +void igPlotHistogramFnPtr (const(char)* label, float function (void* data, int idx) values_getter, void* data, int values_count, int values_offset, const(char)* overlay_text, float scale_min, float scale_max, ImVec2 graph_size); +void igValueBool (const(char)* prefix, bool b); +void igValueInt (const(char)* prefix, int v); +void igValueUint (const(char)* prefix, uint v); +void igValueFloat (const(char)* prefix, float v, const(char)* float_format); +bool igBeginMainMenuBar (); +void igEndMainMenuBar (); +bool igBeginMenuBar (); +void igEndMenuBar (); +bool igBeginMenu (const(char)* label, bool enabled); +void igEndMenu (); +bool igMenuItemBool (const(char)* label, const(char)* shortcut, bool selected, bool enabled); +bool igMenuItemBoolPtr (const(char)* label, const(char)* shortcut, bool* p_selected, bool enabled); +void igBeginTooltip (); +void igEndTooltip (); +void igSetTooltip (const(char)* fmt, ...); +void igSetTooltipV (const(char)* fmt, va_list args); +void igOpenPopup (const(char)* str_id); +bool igBeginPopup (const(char)* str_id, ImGuiWindowFlags flags); +bool igBeginPopupContextItem (const(char)* str_id, int mouse_button); +bool igBeginPopupContextWindow (const(char)* str_id, int mouse_button, bool also_over_items); +bool igBeginPopupContextVoid (const(char)* str_id, int mouse_button); +bool igBeginPopupModal (const(char)* name, bool* p_open, ImGuiWindowFlags flags); +void igEndPopup (); +bool igOpenPopupOnItemClick (const(char)* str_id, int mouse_button); +bool igIsPopupOpen (const(char)* str_id); +void igCloseCurrentPopup (); +void igColumns (int count, const(char)* id, bool border); +void igNextColumn (); +int igGetColumnIndex (); +float igGetColumnWidth (int column_index); +void igSetColumnWidth (int column_index, float width); +float igGetColumnOffset (int column_index); +void igSetColumnOffset (int column_index, float offset_x); +int igGetColumnsCount (); +bool igBeginTabBar (const(char)* str_id, ImGuiTabBarFlags flags); +void igEndTabBar (); +bool igBeginTabItem (const(char)* label, bool* p_open, ImGuiTabItemFlags flags); +void igEndTabItem (); +void igSetTabItemClosed (const(char)* tab_or_docked_window_label); +void igLogToTTY (int auto_open_depth); +void igLogToFile (int auto_open_depth, const(char)* filename); +void igLogToClipboard (int auto_open_depth); +void igLogFinish (); +void igLogButtons (); +bool igBeginDragDropSource (ImGuiDragDropFlags flags); +bool igSetDragDropPayload (const(char)* type, const(void)* data, size_t sz, ImGuiCond cond); +void igEndDragDropSource (); +bool igBeginDragDropTarget (); +const(ImGuiPayload)* igAcceptDragDropPayload (const(char)* type, ImGuiDragDropFlags flags); +void igEndDragDropTarget (); +const(ImGuiPayload)* igGetDragDropPayload (); +void igPushClipRect (const ImVec2 clip_rect_min, const ImVec2 clip_rect_max, bool intersect_with_current_clip_rect); +void igPopClipRect (); +void igSetItemDefaultFocus (); +void igSetKeyboardFocusHere (int offset); +bool igIsItemHovered (ImGuiHoveredFlags flags); +bool igIsItemActive (); +bool igIsItemFocused (); +bool igIsItemClicked (int mouse_button); +bool igIsItemVisible (); +bool igIsItemEdited (); +bool igIsItemActivated (); +bool igIsItemDeactivated (); +bool igIsItemDeactivatedAfterEdit (); +bool igIsAnyItemHovered (); +bool igIsAnyItemActive (); +bool igIsAnyItemFocused (); +ImVec2 igGetItemRectMin (); +ImVec2 igGetItemRectMax (); +ImVec2 igGetItemRectSize (); +void igSetItemAllowOverlap (); +bool igIsRectVisible (const ImVec2 size); +bool igIsRectVisibleVec2 (const ImVec2 rect_min, const ImVec2 rect_max); +double igGetTime (); +int igGetFrameCount (); +ImDrawList* igGetBackgroundDrawList (); +ImDrawList* igGetForegroundDrawList (); +ImDrawListSharedData* igGetDrawListSharedData (); +const(char)* igGetStyleColorName (ImGuiCol idx); +void igSetStateStorage (ImGuiStorage* storage); +ImGuiStorage* igGetStateStorage (); +ImVec2 igCalcTextSize (const(char)* text, const(char)* text_end, bool hide_text_after_double_hash, float wrap_width); +void igCalcListClipping (int items_count, float items_height, int* out_items_display_start, int* out_items_display_end); +bool igBeginChildFrame (ImGuiID id, const ImVec2 size, ImGuiWindowFlags flags); +void igEndChildFrame (); +ImVec4 igColorConvertU32ToFloat4 (ImU32 in_); +ImU32 igColorConvertFloat4ToU32 (const ImVec4 in_); +int igGetKeyIndex (ImGuiKey imgui_key); +bool igIsKeyDown (int user_key_index); +bool igIsKeyPressed (int user_key_index, bool repeat); +bool igIsKeyReleased (int user_key_index); +int igGetKeyPressedAmount (int key_index, float repeat_delay, float rate); +bool igIsMouseDown (int button); +bool igIsAnyMouseDown (); +bool igIsMouseClicked (int button, bool repeat); +bool igIsMouseDoubleClicked (int button); +bool igIsMouseReleased (int button); +bool igIsMouseDragging (int button, float lock_threshold); +bool igIsMouseHoveringRect (const ImVec2 r_min, const ImVec2 r_max, bool clip); +bool igIsMousePosValid (const(ImVec2)* mouse_pos); +ImVec2 igGetMousePos (); +ImVec2 igGetMousePosOnOpeningCurrentPopup (); +ImVec2 igGetMouseDragDelta (int button, float lock_threshold); +void igResetMouseDragDelta (int button); +ImGuiMouseCursor igGetMouseCursor (); +void igSetMouseCursor (ImGuiMouseCursor type); +void igCaptureKeyboardFromApp (bool want_capture_keyboard_value); +void igCaptureMouseFromApp (bool want_capture_mouse_value); +const(char)* igGetClipboardText (); +void igSetClipboardText (const(char)* text); +void igLoadIniSettingsFromDisk (const(char)* ini_filename); +void igLoadIniSettingsFromMemory (const(char)* ini_data, size_t ini_size); +void igSaveIniSettingsToDisk (const(char)* ini_filename); +const(char)* igSaveIniSettingsToMemory (size_t* out_ini_size); +void igSetAllocatorFunctions (void* function (size_t sz, void* user_data) alloc_func, void function (void* ptr, void* user_data) free_func, void* user_data); +void* igMemAlloc (size_t size); +void igMemFree (void* ptr); +ImGuiStyle* ImGuiStyle_ImGuiStyle (); +void ImGuiStyle_destroy (ImGuiStyle* self); +void ImGuiStyle_ScaleAllSizes (ImGuiStyle* self, float scale_factor); +void ImGuiIO_AddInputCharacter (ImGuiIO* self, uint c); +void ImGuiIO_AddInputCharactersUTF8 (ImGuiIO* self, const(char)* str); +void ImGuiIO_ClearInputCharacters (ImGuiIO* self); +ImGuiIO* ImGuiIO_ImGuiIO (); +void ImGuiIO_destroy (ImGuiIO* self); +ImGuiInputTextCallbackData* ImGuiInputTextCallbackData_ImGuiInputTextCallbackData (); +void ImGuiInputTextCallbackData_destroy (ImGuiInputTextCallbackData* self); +void ImGuiInputTextCallbackData_DeleteChars (ImGuiInputTextCallbackData* self, int pos, int bytes_count); +void ImGuiInputTextCallbackData_InsertChars (ImGuiInputTextCallbackData* self, int pos, const(char)* text, const(char)* text_end); +bool ImGuiInputTextCallbackData_HasSelection (ImGuiInputTextCallbackData* self); +ImGuiPayload* ImGuiPayload_ImGuiPayload (); +void ImGuiPayload_destroy (ImGuiPayload* self); +void ImGuiPayload_Clear (ImGuiPayload* self); +bool ImGuiPayload_IsDataType (ImGuiPayload* self, const(char)* type); +bool ImGuiPayload_IsPreview (ImGuiPayload* self); +bool ImGuiPayload_IsDelivery (ImGuiPayload* self); +ImGuiOnceUponAFrame* ImGuiOnceUponAFrame_ImGuiOnceUponAFrame (); +void ImGuiOnceUponAFrame_destroy (ImGuiOnceUponAFrame* self); +ImGuiTextFilter* ImGuiTextFilter_ImGuiTextFilter (const(char)* default_filter); +void ImGuiTextFilter_destroy (ImGuiTextFilter* self); +bool ImGuiTextFilter_Draw (ImGuiTextFilter* self, const(char)* label, float width); +bool ImGuiTextFilter_PassFilter (ImGuiTextFilter* self, const(char)* text, const(char)* text_end); +void ImGuiTextFilter_Build (ImGuiTextFilter* self); +void ImGuiTextFilter_Clear (ImGuiTextFilter* self); +bool ImGuiTextFilter_IsActive (ImGuiTextFilter* self); +ImGuiTextRange* ImGuiTextRange_ImGuiTextRange (); +void ImGuiTextRange_destroy (ImGuiTextRange* self); +ImGuiTextRange* ImGuiTextRange_ImGuiTextRangeStr (const(char)* _b, const(char)* _e); +bool ImGuiTextRange_empty (ImGuiTextRange* self); +void ImGuiTextRange_split (ImGuiTextRange* self, char separator, ImVector_ImGuiTextRange* out_); +ImGuiTextBuffer* ImGuiTextBuffer_ImGuiTextBuffer (); +void ImGuiTextBuffer_destroy (ImGuiTextBuffer* self); +const(char)* ImGuiTextBuffer_begin (ImGuiTextBuffer* self); +const(char)* ImGuiTextBuffer_end (ImGuiTextBuffer* self); +int ImGuiTextBuffer_size (ImGuiTextBuffer* self); +bool ImGuiTextBuffer_empty (ImGuiTextBuffer* self); +void ImGuiTextBuffer_clear (ImGuiTextBuffer* self); +void ImGuiTextBuffer_reserve (ImGuiTextBuffer* self, int capacity); +const(char)* ImGuiTextBuffer_c_str (ImGuiTextBuffer* self); +void ImGuiTextBuffer_append (ImGuiTextBuffer* self, const(char)* str, const(char)* str_end); +void ImGuiTextBuffer_appendfv (ImGuiTextBuffer* self, const(char)* fmt, va_list args); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairInt (ImGuiID _key, int _val_i); +void ImGuiStoragePair_destroy (ImGuiStoragePair* self); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairFloat (ImGuiID _key, float _val_f); +ImGuiStoragePair* ImGuiStoragePair_ImGuiStoragePairPtr (ImGuiID _key, void* _val_p); +void ImGuiStorage_Clear (ImGuiStorage* self); +int ImGuiStorage_GetInt (ImGuiStorage* self, ImGuiID key, int default_val); +void ImGuiStorage_SetInt (ImGuiStorage* self, ImGuiID key, int val); +bool ImGuiStorage_GetBool (ImGuiStorage* self, ImGuiID key, bool default_val); +void ImGuiStorage_SetBool (ImGuiStorage* self, ImGuiID key, bool val); +float ImGuiStorage_GetFloat (ImGuiStorage* self, ImGuiID key, float default_val); +void ImGuiStorage_SetFloat (ImGuiStorage* self, ImGuiID key, float val); +void* ImGuiStorage_GetVoidPtr (ImGuiStorage* self, ImGuiID key); +void ImGuiStorage_SetVoidPtr (ImGuiStorage* self, ImGuiID key, void* val); +int* ImGuiStorage_GetIntRef (ImGuiStorage* self, ImGuiID key, int default_val); +bool* ImGuiStorage_GetBoolRef (ImGuiStorage* self, ImGuiID key, bool default_val); +float* ImGuiStorage_GetFloatRef (ImGuiStorage* self, ImGuiID key, float default_val); +void** ImGuiStorage_GetVoidPtrRef (ImGuiStorage* self, ImGuiID key, void* default_val); +void ImGuiStorage_SetAllInt (ImGuiStorage* self, int val); +void ImGuiStorage_BuildSortByKey (ImGuiStorage* self); +ImGuiListClipper* ImGuiListClipper_ImGuiListClipper (int items_count, float items_height); +void ImGuiListClipper_destroy (ImGuiListClipper* self); +bool ImGuiListClipper_Step (ImGuiListClipper* self); +void ImGuiListClipper_Begin (ImGuiListClipper* self, int items_count, float items_height); +void ImGuiListClipper_End (ImGuiListClipper* self); +ImColor* ImColor_ImColor (); +void ImColor_destroy (ImColor* self); +ImColor* ImColor_ImColorInt (int r, int g, int b, int a); +ImColor* ImColor_ImColorU32 (ImU32 rgba); +ImColor* ImColor_ImColorFloat (float r, float g, float b, float a); +ImColor* ImColor_ImColorVec4 (const ImVec4 col); +void ImColor_SetHSV (ImColor* self, float h, float s, float v, float a); +ImColor ImColor_HSV (ImColor* self, float h, float s, float v, float a); +ImDrawCmd* ImDrawCmd_ImDrawCmd (); +void ImDrawCmd_destroy (ImDrawCmd* self); +ImDrawListSplitter* ImDrawListSplitter_ImDrawListSplitter (); +void ImDrawListSplitter_destroy (ImDrawListSplitter* self); +void ImDrawListSplitter_Clear (ImDrawListSplitter* self); +void ImDrawListSplitter_ClearFreeMemory (ImDrawListSplitter* self); +void ImDrawListSplitter_Split (ImDrawListSplitter* self, ImDrawList* draw_list, int count); +void ImDrawListSplitter_Merge (ImDrawListSplitter* self, ImDrawList* draw_list); +void ImDrawListSplitter_SetCurrentChannel (ImDrawListSplitter* self, ImDrawList* draw_list, int channel_idx); +ImDrawList* ImDrawList_ImDrawList (const(ImDrawListSharedData)* shared_data); +void ImDrawList_destroy (ImDrawList* self); +void ImDrawList_PushClipRect (ImDrawList* self, ImVec2 clip_rect_min, ImVec2 clip_rect_max, bool intersect_with_current_clip_rect); +void ImDrawList_PushClipRectFullScreen (ImDrawList* self); +void ImDrawList_PopClipRect (ImDrawList* self); +void ImDrawList_PushTextureID (ImDrawList* self, ImTextureID texture_id); +void ImDrawList_PopTextureID (ImDrawList* self); +ImVec2 ImDrawList_GetClipRectMin (ImDrawList* self); +ImVec2 ImDrawList_GetClipRectMax (ImDrawList* self); +void ImDrawList_AddLine (ImDrawList* self, const ImVec2 p1, const ImVec2 p2, ImU32 col, float thickness); +void ImDrawList_AddRect (ImDrawList* self, const ImVec2 p_min, const ImVec2 p_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners, float thickness); +void ImDrawList_AddRectFilled (ImDrawList* self, const ImVec2 p_min, const ImVec2 p_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners); +void ImDrawList_AddRectFilledMultiColor (ImDrawList* self, const ImVec2 p_min, const ImVec2 p_max, ImU32 col_upr_left, ImU32 col_upr_right, ImU32 col_bot_right, ImU32 col_bot_left); +void ImDrawList_AddQuad (ImDrawList* self, const ImVec2 p1, const ImVec2 p2, const ImVec2 p3, const ImVec2 p4, ImU32 col, float thickness); +void ImDrawList_AddQuadFilled (ImDrawList* self, const ImVec2 p1, const ImVec2 p2, const ImVec2 p3, const ImVec2 p4, ImU32 col); +void ImDrawList_AddTriangle (ImDrawList* self, const ImVec2 p1, const ImVec2 p2, const ImVec2 p3, ImU32 col, float thickness); +void ImDrawList_AddTriangleFilled (ImDrawList* self, const ImVec2 p1, const ImVec2 p2, const ImVec2 p3, ImU32 col); +void ImDrawList_AddCircle (ImDrawList* self, const ImVec2 center, float radius, ImU32 col, int num_segments, float thickness); +void ImDrawList_AddCircleFilled (ImDrawList* self, const ImVec2 center, float radius, ImU32 col, int num_segments); +void ImDrawList_AddText (ImDrawList* self, const ImVec2 pos, ImU32 col, const(char)* text_begin, const(char)* text_end); +void ImDrawList_AddTextFontPtr (ImDrawList* self, const(ImFont)* font, float font_size, const ImVec2 pos, ImU32 col, const(char)* text_begin, const(char)* text_end, float wrap_width, const(ImVec4)* cpu_fine_clip_rect); +void ImDrawList_AddPolyline (ImDrawList* self, const(ImVec2)* points, int num_points, ImU32 col, bool closed, float thickness); +void ImDrawList_AddConvexPolyFilled (ImDrawList* self, const(ImVec2)* points, int num_points, ImU32 col); +void ImDrawList_AddBezierCurve (ImDrawList* self, const ImVec2 pos0, const ImVec2 cp0, const ImVec2 cp1, const ImVec2 pos1, ImU32 col, float thickness, int num_segments); +void ImDrawList_AddImage (ImDrawList* self, ImTextureID user_texture_id, const ImVec2 p_min, const ImVec2 p_max, const ImVec2 uv_min, const ImVec2 uv_max, ImU32 col); +void ImDrawList_AddImageQuad (ImDrawList* self, ImTextureID user_texture_id, const ImVec2 p1, const ImVec2 p2, const ImVec2 p3, const ImVec2 p4, const ImVec2 uv1, const ImVec2 uv2, const ImVec2 uv3, const ImVec2 uv4, ImU32 col); +void ImDrawList_AddImageRounded (ImDrawList* self, ImTextureID user_texture_id, const ImVec2 p_min, const ImVec2 p_max, const ImVec2 uv_min, const ImVec2 uv_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners); +void ImDrawList_PathClear (ImDrawList* self); +void ImDrawList_PathLineTo (ImDrawList* self, const ImVec2 pos); +void ImDrawList_PathLineToMergeDuplicate (ImDrawList* self, const ImVec2 pos); +void ImDrawList_PathFillConvex (ImDrawList* self, ImU32 col); +void ImDrawList_PathStroke (ImDrawList* self, ImU32 col, bool closed, float thickness); +void ImDrawList_PathArcTo (ImDrawList* self, const ImVec2 center, float radius, float a_min, float a_max, int num_segments); +void ImDrawList_PathArcToFast (ImDrawList* self, const ImVec2 center, float radius, int a_min_of_12, int a_max_of_12); +void ImDrawList_PathBezierCurveTo (ImDrawList* self, const ImVec2 p1, const ImVec2 p2, const ImVec2 p3, int num_segments); +void ImDrawList_PathRect (ImDrawList* self, const ImVec2 rect_min, const ImVec2 rect_max, float rounding, ImDrawCornerFlags rounding_corners); +void ImDrawList_AddCallback (ImDrawList* self, ImDrawCallback callback, void* callback_data); +void ImDrawList_AddDrawCmd (ImDrawList* self); +ImDrawList* ImDrawList_CloneOutput (ImDrawList* self); +void ImDrawList_ChannelsSplit (ImDrawList* self, int count); +void ImDrawList_ChannelsMerge (ImDrawList* self); +void ImDrawList_ChannelsSetCurrent (ImDrawList* self, int n); +void ImDrawList_Clear (ImDrawList* self); +void ImDrawList_ClearFreeMemory (ImDrawList* self); +void ImDrawList_PrimReserve (ImDrawList* self, int idx_count, int vtx_count); +void ImDrawList_PrimRect (ImDrawList* self, const ImVec2 a, const ImVec2 b, ImU32 col); +void ImDrawList_PrimRectUV (ImDrawList* self, const ImVec2 a, const ImVec2 b, const ImVec2 uv_a, const ImVec2 uv_b, ImU32 col); +void ImDrawList_PrimQuadUV (ImDrawList* self, const ImVec2 a, const ImVec2 b, const ImVec2 c, const ImVec2 d, const ImVec2 uv_a, const ImVec2 uv_b, const ImVec2 uv_c, const ImVec2 uv_d, ImU32 col); +void ImDrawList_PrimWriteVtx (ImDrawList* self, const ImVec2 pos, const ImVec2 uv, ImU32 col); +void ImDrawList_PrimWriteIdx (ImDrawList* self, ImDrawIdx idx); +void ImDrawList_PrimVtx (ImDrawList* self, const ImVec2 pos, const ImVec2 uv, ImU32 col); +void ImDrawList_UpdateClipRect (ImDrawList* self); +void ImDrawList_UpdateTextureID (ImDrawList* self); +ImDrawData* ImDrawData_ImDrawData (); +void ImDrawData_destroy (ImDrawData* self); +void ImDrawData_Clear (ImDrawData* self); +void ImDrawData_DeIndexAllBuffers (ImDrawData* self); +void ImDrawData_ScaleClipRects (ImDrawData* self, const ImVec2 fb_scale); +ImFontConfig* ImFontConfig_ImFontConfig (); +void ImFontConfig_destroy (ImFontConfig* self); +ImFontGlyphRangesBuilder* ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder (); +void ImFontGlyphRangesBuilder_destroy (ImFontGlyphRangesBuilder* self); +void ImFontGlyphRangesBuilder_Clear (ImFontGlyphRangesBuilder* self); +bool ImFontGlyphRangesBuilder_GetBit (ImFontGlyphRangesBuilder* self, int n); +void ImFontGlyphRangesBuilder_SetBit (ImFontGlyphRangesBuilder* self, int n); +void ImFontGlyphRangesBuilder_AddChar (ImFontGlyphRangesBuilder* self, ImWchar c); +void ImFontGlyphRangesBuilder_AddText (ImFontGlyphRangesBuilder* self, const(char)* text, const(char)* text_end); +void ImFontGlyphRangesBuilder_AddRanges (ImFontGlyphRangesBuilder* self, const(ImWchar)* ranges); +void ImFontGlyphRangesBuilder_BuildRanges (ImFontGlyphRangesBuilder* self, ImVector_ImWchar* out_ranges); +ImFontAtlasCustomRect* ImFontAtlasCustomRect_ImFontAtlasCustomRect (); +void ImFontAtlasCustomRect_destroy (ImFontAtlasCustomRect* self); +bool ImFontAtlasCustomRect_IsPacked (ImFontAtlasCustomRect* self); +ImFontAtlas* ImFontAtlas_ImFontAtlas (); +void ImFontAtlas_destroy (ImFontAtlas* self); +ImFont* ImFontAtlas_AddFont (ImFontAtlas* self, const(ImFontConfig)* font_cfg); +ImFont* ImFontAtlas_AddFontDefault (ImFontAtlas* self, const(ImFontConfig)* font_cfg); +ImFont* ImFontAtlas_AddFontFromFileTTF (ImFontAtlas* self, const(char)* filename, float size_pixels, const(ImFontConfig)* font_cfg, const(ImWchar)* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryTTF (ImFontAtlas* self, void* font_data, int font_size, float size_pixels, const(ImFontConfig)* font_cfg, const(ImWchar)* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryCompressedTTF (ImFontAtlas* self, const(void)* compressed_font_data, int compressed_font_size, float size_pixels, const(ImFontConfig)* font_cfg, const(ImWchar)* glyph_ranges); +ImFont* ImFontAtlas_AddFontFromMemoryCompressedBase85TTF (ImFontAtlas* self, const(char)* compressed_font_data_base85, float size_pixels, const(ImFontConfig)* font_cfg, const(ImWchar)* glyph_ranges); +void ImFontAtlas_ClearInputData (ImFontAtlas* self); +void ImFontAtlas_ClearTexData (ImFontAtlas* self); +void ImFontAtlas_ClearFonts (ImFontAtlas* self); +void ImFontAtlas_Clear (ImFontAtlas* self); +bool ImFontAtlas_Build (ImFontAtlas* self); +void ImFontAtlas_GetTexDataAsAlpha8 (ImFontAtlas* self, ubyte** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel); +void ImFontAtlas_GetTexDataAsRGBA32 (ImFontAtlas* self, ubyte** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel); +bool ImFontAtlas_IsBuilt (ImFontAtlas* self); +void ImFontAtlas_SetTexID (ImFontAtlas* self, ImTextureID id); +const(ImWchar)* ImFontAtlas_GetGlyphRangesDefault (ImFontAtlas* self); +const(ImWchar)* ImFontAtlas_GetGlyphRangesKorean (ImFontAtlas* self); +const(ImWchar)* ImFontAtlas_GetGlyphRangesJapanese (ImFontAtlas* self); +const(ImWchar)* ImFontAtlas_GetGlyphRangesChineseFull (ImFontAtlas* self); +const(ImWchar)* ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon (ImFontAtlas* self); +const(ImWchar)* ImFontAtlas_GetGlyphRangesCyrillic (ImFontAtlas* self); +const(ImWchar)* ImFontAtlas_GetGlyphRangesThai (ImFontAtlas* self); +const(ImWchar)* ImFontAtlas_GetGlyphRangesVietnamese (ImFontAtlas* self); +int ImFontAtlas_AddCustomRectRegular (ImFontAtlas* self, uint id, int width, int height); +int ImFontAtlas_AddCustomRectFontGlyph (ImFontAtlas* self, ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2 offset); +const(ImFontAtlasCustomRect)* ImFontAtlas_GetCustomRectByIndex (ImFontAtlas* self, int index); +void ImFontAtlas_CalcCustomRectUV (ImFontAtlas* self, const(ImFontAtlasCustomRect)* rect, ImVec2* out_uv_min, ImVec2* out_uv_max); +bool ImFontAtlas_GetMouseCursorTexData (ImFontAtlas* self, ImGuiMouseCursor cursor, ImVec2* out_offset, ImVec2* out_size, ref ImVec2[2] out_uv_border, ref ImVec2[2] out_uv_fill); +ImFont* ImFont_ImFont (); +void ImFont_destroy (ImFont* self); +const(ImFontGlyph)* ImFont_FindGlyph (ImFont* self, ImWchar c); +const(ImFontGlyph)* ImFont_FindGlyphNoFallback (ImFont* self, ImWchar c); +float ImFont_GetCharAdvance (ImFont* self, ImWchar c); +bool ImFont_IsLoaded (ImFont* self); +const(char)* ImFont_GetDebugName (ImFont* self); +ImVec2 ImFont_CalcTextSizeA (ImFont* self, float size, float max_width, float wrap_width, const(char)* text_begin, const(char)* text_end, const(char*)* remaining); +const(char)* ImFont_CalcWordWrapPositionA (ImFont* self, float scale, const(char)* text, const(char)* text_end, float wrap_width); +void ImFont_RenderChar (ImFont* self, ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, ImWchar c); +void ImFont_RenderText (ImFont* self, ImDrawList* draw_list, float size, ImVec2 pos, ImU32 col, const ImVec4 clip_rect, const(char)* text_begin, const(char)* text_end, float wrap_width, bool cpu_fine_clip); +void ImFont_BuildLookupTable (ImFont* self); +void ImFont_ClearOutputData (ImFont* self); +void ImFont_GrowIndex (ImFont* self, int new_size); +void ImFont_AddGlyph (ImFont* self, ImWchar c, float x0, float y0, float x1, float y1, float u0, float v0, float u1, float v1, float advance_x); +void ImFont_AddRemapChar (ImFont* self, ImWchar dst, ImWchar src, bool overwrite_dst); +void ImFont_SetFallbackChar (ImFont* self, ImWchar c); +void igGetWindowPos_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetWindowPos_nonUDT2 (); +void igGetWindowSize_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetWindowSize_nonUDT2 (); +void igGetContentRegionMax_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetContentRegionMax_nonUDT2 (); +void igGetContentRegionAvail_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetContentRegionAvail_nonUDT2 (); +void igGetWindowContentRegionMin_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetWindowContentRegionMin_nonUDT2 (); +void igGetWindowContentRegionMax_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetWindowContentRegionMax_nonUDT2 (); +void igGetFontTexUvWhitePixel_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetFontTexUvWhitePixel_nonUDT2 (); +void igGetCursorPos_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetCursorPos_nonUDT2 (); +void igGetCursorStartPos_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetCursorStartPos_nonUDT2 (); +void igGetCursorScreenPos_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetCursorScreenPos_nonUDT2 (); +void igGetItemRectMin_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetItemRectMin_nonUDT2 (); +void igGetItemRectMax_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetItemRectMax_nonUDT2 (); +void igGetItemRectSize_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetItemRectSize_nonUDT2 (); +void igCalcTextSize_nonUDT (ImVec2* pOut, const(char)* text, const(char)* text_end, bool hide_text_after_double_hash, float wrap_width); +ImVec2_Simple igCalcTextSize_nonUDT2 (const(char)* text, const(char)* text_end, bool hide_text_after_double_hash, float wrap_width); +void igColorConvertU32ToFloat4_nonUDT (ImVec4* pOut, ImU32 in_); +ImVec4_Simple igColorConvertU32ToFloat4_nonUDT2 (ImU32 in_); +void igGetMousePos_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetMousePos_nonUDT2 (); +void igGetMousePosOnOpeningCurrentPopup_nonUDT (ImVec2* pOut); +ImVec2_Simple igGetMousePosOnOpeningCurrentPopup_nonUDT2 (); +void igGetMouseDragDelta_nonUDT (ImVec2* pOut, int button, float lock_threshold); +ImVec2_Simple igGetMouseDragDelta_nonUDT2 (int button, float lock_threshold); +void ImColor_HSV_nonUDT (ImColor* pOut, ImColor* self, float h, float s, float v, float a); +ImColor_Simple ImColor_HSV_nonUDT2 (ImColor* self, float h, float s, float v, float a); +void ImDrawList_GetClipRectMin_nonUDT (ImVec2* pOut, ImDrawList* self); +ImVec2_Simple ImDrawList_GetClipRectMin_nonUDT2 (ImDrawList* self); +void ImDrawList_GetClipRectMax_nonUDT (ImVec2* pOut, ImDrawList* self); +ImVec2_Simple ImDrawList_GetClipRectMax_nonUDT2 (ImDrawList* self); +void ImFont_CalcTextSizeA_nonUDT (ImVec2* pOut, ImFont* self, float size, float max_width, float wrap_width, const(char)* text_begin, const(char)* text_end, const(char*)* remaining); +ImVec2_Simple ImFont_CalcTextSizeA_nonUDT2 (ImFont* self, float size, float max_width, float wrap_width, const(char)* text_begin, const(char)* text_end, const(char*)* remaining); + +/////////////////////////hand written functions +//no LogTextV +void igLogText (const(char)* fmt, ...); +//no appendfV +void ImGuiTextBuffer_appendf (ImGuiTextBuffer* buffer, const(char)* fmt, ...); +//for getting FLT_MAX in bindings +float igGET_FLT_MAX (); +//not const args from & to * +void igColorConvertRGBtoHSV (float r, float g, float b, float* out_h, float* out_s, float* out_v); +void igColorConvertHSVtoRGB (float h, float s, float v, float* out_r, float* out_g, float* out_b); + +ImVector_ImWchar* ImVector_ImWchar_create (); +void ImVector_ImWchar_destroy (ImVector_ImWchar* self); +void ImVector_ImWchar_Init (ImVector_ImWchar* p); +void ImVector_ImWchar_UnInit (ImVector_ImWchar* p); +//CIMGUI_INCLUDED diff --git a/demos/external/sources/glad/gl/all.d b/demos/external/sources/glad/gl/all.d new file mode 100644 index 0000000..99c9ee4 --- /dev/null +++ b/demos/external/sources/glad/gl/all.d @@ -0,0 +1,28 @@ +/* + + OpenGL, OpenGL ES loader generated by glad 0.1.33 on Fri Nov 8 17:14:30 2019. + + Language/Generator: D + Specification: gl + APIs: gl=3.3, gles2=3.0 + Profile: compatibility + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="compatibility" --api="gl=3.3,gles2=3.0" --generator="d" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=compatibility&language=d&specification=gl&loader=on&api=gl%3D3.3&api=gles2%3D3.0 +*/ + +module glad.gl.all; + + +public import glad.gl.funcs; +public import glad.gl.ext; +public import glad.gl.enums; +public import glad.gl.types; diff --git a/demos/external/sources/glad/gl/enums.d b/demos/external/sources/glad/gl/enums.d new file mode 100644 index 0000000..c840fbc --- /dev/null +++ b/demos/external/sources/glad/gl/enums.d @@ -0,0 +1,1302 @@ +module glad.gl.enums; + + +private import glad.gl.types; +enum ubyte GL_FALSE = 0; +enum ubyte GL_TRUE = 1; +enum uint GL_NO_ERROR = 0; +enum uint GL_NONE = 0; +enum uint GL_ZERO = 0; +enum uint GL_ONE = 1; +enum uint GL_NONE_OES = 0; +enum uint GL_INVALID_INDEX = 0xFFFFFFFF; +enum ulong GL_TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF; +enum ulong GL_TIMEOUT_IGNORED_APPLE = 0xFFFFFFFFFFFFFFFF; +enum uint GL_VERSION_ES_CL_1_0 = 1; +enum uint GL_VERSION_ES_CM_1_1 = 1; +enum uint GL_VERSION_ES_CL_1_1 = 1; +enum uint GL_DEPTH_BUFFER_BIT = 0x00000100; +enum uint GL_STENCIL_BUFFER_BIT = 0x00000400; +enum uint GL_COLOR_BUFFER_BIT = 0x00004000; +enum uint GL_POINTS = 0x0000; +enum uint GL_LINES = 0x0001; +enum uint GL_LINE_LOOP = 0x0002; +enum uint GL_LINE_STRIP = 0x0003; +enum uint GL_TRIANGLES = 0x0004; +enum uint GL_TRIANGLE_STRIP = 0x0005; +enum uint GL_TRIANGLE_FAN = 0x0006; +enum uint GL_QUADS = 0x0007; +enum uint GL_NEVER = 0x0200; +enum uint GL_LESS = 0x0201; +enum uint GL_EQUAL = 0x0202; +enum uint GL_LEQUAL = 0x0203; +enum uint GL_GREATER = 0x0204; +enum uint GL_NOTEQUAL = 0x0205; +enum uint GL_GEQUAL = 0x0206; +enum uint GL_ALWAYS = 0x0207; +enum uint GL_SRC_COLOR = 0x0300; +enum uint GL_ONE_MINUS_SRC_COLOR = 0x0301; +enum uint GL_SRC_ALPHA = 0x0302; +enum uint GL_ONE_MINUS_SRC_ALPHA = 0x0303; +enum uint GL_DST_ALPHA = 0x0304; +enum uint GL_ONE_MINUS_DST_ALPHA = 0x0305; +enum uint GL_DST_COLOR = 0x0306; +enum uint GL_ONE_MINUS_DST_COLOR = 0x0307; +enum uint GL_SRC_ALPHA_SATURATE = 0x0308; +enum uint GL_FRONT_LEFT = 0x0400; +enum uint GL_FRONT_RIGHT = 0x0401; +enum uint GL_BACK_LEFT = 0x0402; +enum uint GL_BACK_RIGHT = 0x0403; +enum uint GL_FRONT = 0x0404; +enum uint GL_BACK = 0x0405; +enum uint GL_LEFT = 0x0406; +enum uint GL_RIGHT = 0x0407; +enum uint GL_FRONT_AND_BACK = 0x0408; +enum uint GL_INVALID_ENUM = 0x0500; +enum uint GL_INVALID_VALUE = 0x0501; +enum uint GL_INVALID_OPERATION = 0x0502; +enum uint GL_OUT_OF_MEMORY = 0x0505; +enum uint GL_CW = 0x0900; +enum uint GL_CCW = 0x0901; +enum uint GL_POINT_SIZE = 0x0B11; +enum uint GL_POINT_SIZE_RANGE = 0x0B12; +enum uint GL_POINT_SIZE_GRANULARITY = 0x0B13; +enum uint GL_LINE_SMOOTH = 0x0B20; +enum uint GL_LINE_WIDTH = 0x0B21; +enum uint GL_LINE_WIDTH_RANGE = 0x0B22; +enum uint GL_LINE_WIDTH_GRANULARITY = 0x0B23; +enum uint GL_POLYGON_MODE = 0x0B40; +enum uint GL_POLYGON_SMOOTH = 0x0B41; +enum uint GL_CULL_FACE = 0x0B44; +enum uint GL_CULL_FACE_MODE = 0x0B45; +enum uint GL_FRONT_FACE = 0x0B46; +enum uint GL_DEPTH_RANGE = 0x0B70; +enum uint GL_DEPTH_TEST = 0x0B71; +enum uint GL_DEPTH_WRITEMASK = 0x0B72; +enum uint GL_DEPTH_CLEAR_VALUE = 0x0B73; +enum uint GL_DEPTH_FUNC = 0x0B74; +enum uint GL_STENCIL_TEST = 0x0B90; +enum uint GL_STENCIL_CLEAR_VALUE = 0x0B91; +enum uint GL_STENCIL_FUNC = 0x0B92; +enum uint GL_STENCIL_VALUE_MASK = 0x0B93; +enum uint GL_STENCIL_FAIL = 0x0B94; +enum uint GL_STENCIL_PASS_DEPTH_FAIL = 0x0B95; +enum uint GL_STENCIL_PASS_DEPTH_PASS = 0x0B96; +enum uint GL_STENCIL_REF = 0x0B97; +enum uint GL_STENCIL_WRITEMASK = 0x0B98; +enum uint GL_VIEWPORT = 0x0BA2; +enum uint GL_DITHER = 0x0BD0; +enum uint GL_BLEND_DST = 0x0BE0; +enum uint GL_BLEND_SRC = 0x0BE1; +enum uint GL_BLEND = 0x0BE2; +enum uint GL_LOGIC_OP_MODE = 0x0BF0; +enum uint GL_DRAW_BUFFER = 0x0C01; +enum uint GL_READ_BUFFER = 0x0C02; +enum uint GL_SCISSOR_BOX = 0x0C10; +enum uint GL_SCISSOR_TEST = 0x0C11; +enum uint GL_COLOR_CLEAR_VALUE = 0x0C22; +enum uint GL_COLOR_WRITEMASK = 0x0C23; +enum uint GL_DOUBLEBUFFER = 0x0C32; +enum uint GL_STEREO = 0x0C33; +enum uint GL_LINE_SMOOTH_HINT = 0x0C52; +enum uint GL_POLYGON_SMOOTH_HINT = 0x0C53; +enum uint GL_UNPACK_SWAP_BYTES = 0x0CF0; +enum uint GL_UNPACK_LSB_FIRST = 0x0CF1; +enum uint GL_UNPACK_ROW_LENGTH = 0x0CF2; +enum uint GL_UNPACK_SKIP_ROWS = 0x0CF3; +enum uint GL_UNPACK_SKIP_PIXELS = 0x0CF4; +enum uint GL_UNPACK_ALIGNMENT = 0x0CF5; +enum uint GL_PACK_SWAP_BYTES = 0x0D00; +enum uint GL_PACK_LSB_FIRST = 0x0D01; +enum uint GL_PACK_ROW_LENGTH = 0x0D02; +enum uint GL_PACK_SKIP_ROWS = 0x0D03; +enum uint GL_PACK_SKIP_PIXELS = 0x0D04; +enum uint GL_PACK_ALIGNMENT = 0x0D05; +enum uint GL_MAX_TEXTURE_SIZE = 0x0D33; +enum uint GL_MAX_VIEWPORT_DIMS = 0x0D3A; +enum uint GL_SUBPIXEL_BITS = 0x0D50; +enum uint GL_TEXTURE_1D = 0x0DE0; +enum uint GL_TEXTURE_2D = 0x0DE1; +enum uint GL_TEXTURE_WIDTH = 0x1000; +enum uint GL_TEXTURE_HEIGHT = 0x1001; +enum uint GL_TEXTURE_BORDER_COLOR = 0x1004; +enum uint GL_DONT_CARE = 0x1100; +enum uint GL_FASTEST = 0x1101; +enum uint GL_NICEST = 0x1102; +enum uint GL_BYTE = 0x1400; +enum uint GL_UNSIGNED_BYTE = 0x1401; +enum uint GL_SHORT = 0x1402; +enum uint GL_UNSIGNED_SHORT = 0x1403; +enum uint GL_INT = 0x1404; +enum uint GL_UNSIGNED_INT = 0x1405; +enum uint GL_FLOAT = 0x1406; +enum uint GL_STACK_OVERFLOW = 0x0503; +enum uint GL_STACK_UNDERFLOW = 0x0504; +enum uint GL_CLEAR = 0x1500; +enum uint GL_AND = 0x1501; +enum uint GL_AND_REVERSE = 0x1502; +enum uint GL_COPY = 0x1503; +enum uint GL_AND_INVERTED = 0x1504; +enum uint GL_NOOP = 0x1505; +enum uint GL_XOR = 0x1506; +enum uint GL_OR = 0x1507; +enum uint GL_NOR = 0x1508; +enum uint GL_EQUIV = 0x1509; +enum uint GL_INVERT = 0x150A; +enum uint GL_OR_REVERSE = 0x150B; +enum uint GL_COPY_INVERTED = 0x150C; +enum uint GL_OR_INVERTED = 0x150D; +enum uint GL_NAND = 0x150E; +enum uint GL_SET = 0x150F; +enum uint GL_TEXTURE = 0x1702; +enum uint GL_COLOR = 0x1800; +enum uint GL_DEPTH = 0x1801; +enum uint GL_STENCIL = 0x1802; +enum uint GL_STENCIL_INDEX = 0x1901; +enum uint GL_DEPTH_COMPONENT = 0x1902; +enum uint GL_RED = 0x1903; +enum uint GL_GREEN = 0x1904; +enum uint GL_BLUE = 0x1905; +enum uint GL_ALPHA = 0x1906; +enum uint GL_RGB = 0x1907; +enum uint GL_RGBA = 0x1908; +enum uint GL_POINT = 0x1B00; +enum uint GL_LINE = 0x1B01; +enum uint GL_FILL = 0x1B02; +enum uint GL_KEEP = 0x1E00; +enum uint GL_REPLACE = 0x1E01; +enum uint GL_INCR = 0x1E02; +enum uint GL_DECR = 0x1E03; +enum uint GL_VENDOR = 0x1F00; +enum uint GL_RENDERER = 0x1F01; +enum uint GL_VERSION = 0x1F02; +enum uint GL_EXTENSIONS = 0x1F03; +enum uint GL_NEAREST = 0x2600; +enum uint GL_LINEAR = 0x2601; +enum uint GL_NEAREST_MIPMAP_NEAREST = 0x2700; +enum uint GL_LINEAR_MIPMAP_NEAREST = 0x2701; +enum uint GL_NEAREST_MIPMAP_LINEAR = 0x2702; +enum uint GL_LINEAR_MIPMAP_LINEAR = 0x2703; +enum uint GL_TEXTURE_MAG_FILTER = 0x2800; +enum uint GL_TEXTURE_MIN_FILTER = 0x2801; +enum uint GL_TEXTURE_WRAP_S = 0x2802; +enum uint GL_TEXTURE_WRAP_T = 0x2803; +enum uint GL_REPEAT = 0x2901; +enum uint GL_CURRENT_BIT = 0x00000001; +enum uint GL_POINT_BIT = 0x00000002; +enum uint GL_LINE_BIT = 0x00000004; +enum uint GL_POLYGON_BIT = 0x00000008; +enum uint GL_POLYGON_STIPPLE_BIT = 0x00000010; +enum uint GL_PIXEL_MODE_BIT = 0x00000020; +enum uint GL_LIGHTING_BIT = 0x00000040; +enum uint GL_FOG_BIT = 0x00000080; +enum uint GL_ACCUM_BUFFER_BIT = 0x00000200; +enum uint GL_VIEWPORT_BIT = 0x00000800; +enum uint GL_TRANSFORM_BIT = 0x00001000; +enum uint GL_ENABLE_BIT = 0x00002000; +enum uint GL_HINT_BIT = 0x00008000; +enum uint GL_EVAL_BIT = 0x00010000; +enum uint GL_LIST_BIT = 0x00020000; +enum uint GL_TEXTURE_BIT = 0x00040000; +enum uint GL_SCISSOR_BIT = 0x00080000; +enum uint GL_ALL_ATTRIB_BITS = 0xFFFFFFFF; +enum uint GL_QUAD_STRIP = 0x0008; +enum uint GL_POLYGON = 0x0009; +enum uint GL_ACCUM = 0x0100; +enum uint GL_LOAD = 0x0101; +enum uint GL_RETURN = 0x0102; +enum uint GL_MULT = 0x0103; +enum uint GL_ADD = 0x0104; +enum uint GL_AUX0 = 0x0409; +enum uint GL_AUX1 = 0x040A; +enum uint GL_AUX2 = 0x040B; +enum uint GL_AUX3 = 0x040C; +enum uint GL_2D = 0x0600; +enum uint GL_3D = 0x0601; +enum uint GL_3D_COLOR = 0x0602; +enum uint GL_3D_COLOR_TEXTURE = 0x0603; +enum uint GL_4D_COLOR_TEXTURE = 0x0604; +enum uint GL_PASS_THROUGH_TOKEN = 0x0700; +enum uint GL_POINT_TOKEN = 0x0701; +enum uint GL_LINE_TOKEN = 0x0702; +enum uint GL_POLYGON_TOKEN = 0x0703; +enum uint GL_BITMAP_TOKEN = 0x0704; +enum uint GL_DRAW_PIXEL_TOKEN = 0x0705; +enum uint GL_COPY_PIXEL_TOKEN = 0x0706; +enum uint GL_LINE_RESET_TOKEN = 0x0707; +enum uint GL_EXP = 0x0800; +enum uint GL_EXP2 = 0x0801; +enum uint GL_COEFF = 0x0A00; +enum uint GL_ORDER = 0x0A01; +enum uint GL_DOMAIN = 0x0A02; +enum uint GL_PIXEL_MAP_I_TO_I = 0x0C70; +enum uint GL_PIXEL_MAP_S_TO_S = 0x0C71; +enum uint GL_PIXEL_MAP_I_TO_R = 0x0C72; +enum uint GL_PIXEL_MAP_I_TO_G = 0x0C73; +enum uint GL_PIXEL_MAP_I_TO_B = 0x0C74; +enum uint GL_PIXEL_MAP_I_TO_A = 0x0C75; +enum uint GL_PIXEL_MAP_R_TO_R = 0x0C76; +enum uint GL_PIXEL_MAP_G_TO_G = 0x0C77; +enum uint GL_PIXEL_MAP_B_TO_B = 0x0C78; +enum uint GL_PIXEL_MAP_A_TO_A = 0x0C79; +enum uint GL_CURRENT_COLOR = 0x0B00; +enum uint GL_CURRENT_INDEX = 0x0B01; +enum uint GL_CURRENT_NORMAL = 0x0B02; +enum uint GL_CURRENT_TEXTURE_COORDS = 0x0B03; +enum uint GL_CURRENT_RASTER_COLOR = 0x0B04; +enum uint GL_CURRENT_RASTER_INDEX = 0x0B05; +enum uint GL_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06; +enum uint GL_CURRENT_RASTER_POSITION = 0x0B07; +enum uint GL_CURRENT_RASTER_POSITION_VALID = 0x0B08; +enum uint GL_CURRENT_RASTER_DISTANCE = 0x0B09; +enum uint GL_POINT_SMOOTH = 0x0B10; +enum uint GL_LINE_STIPPLE = 0x0B24; +enum uint GL_LINE_STIPPLE_PATTERN = 0x0B25; +enum uint GL_LINE_STIPPLE_REPEAT = 0x0B26; +enum uint GL_LIST_MODE = 0x0B30; +enum uint GL_MAX_LIST_NESTING = 0x0B31; +enum uint GL_LIST_BASE = 0x0B32; +enum uint GL_LIST_INDEX = 0x0B33; +enum uint GL_POLYGON_STIPPLE = 0x0B42; +enum uint GL_EDGE_FLAG = 0x0B43; +enum uint GL_LIGHTING = 0x0B50; +enum uint GL_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51; +enum uint GL_LIGHT_MODEL_TWO_SIDE = 0x0B52; +enum uint GL_LIGHT_MODEL_AMBIENT = 0x0B53; +enum uint GL_SHADE_MODEL = 0x0B54; +enum uint GL_COLOR_MATERIAL_FACE = 0x0B55; +enum uint GL_COLOR_MATERIAL_PARAMETER = 0x0B56; +enum uint GL_COLOR_MATERIAL = 0x0B57; +enum uint GL_FOG = 0x0B60; +enum uint GL_FOG_INDEX = 0x0B61; +enum uint GL_FOG_DENSITY = 0x0B62; +enum uint GL_FOG_START = 0x0B63; +enum uint GL_FOG_END = 0x0B64; +enum uint GL_FOG_MODE = 0x0B65; +enum uint GL_FOG_COLOR = 0x0B66; +enum uint GL_ACCUM_CLEAR_VALUE = 0x0B80; +enum uint GL_MATRIX_MODE = 0x0BA0; +enum uint GL_NORMALIZE = 0x0BA1; +enum uint GL_MODELVIEW_STACK_DEPTH = 0x0BA3; +enum uint GL_PROJECTION_STACK_DEPTH = 0x0BA4; +enum uint GL_TEXTURE_STACK_DEPTH = 0x0BA5; +enum uint GL_MODELVIEW_MATRIX = 0x0BA6; +enum uint GL_PROJECTION_MATRIX = 0x0BA7; +enum uint GL_TEXTURE_MATRIX = 0x0BA8; +enum uint GL_ATTRIB_STACK_DEPTH = 0x0BB0; +enum uint GL_ALPHA_TEST = 0x0BC0; +enum uint GL_ALPHA_TEST_FUNC = 0x0BC1; +enum uint GL_ALPHA_TEST_REF = 0x0BC2; +enum uint GL_LOGIC_OP = 0x0BF1; +enum uint GL_AUX_BUFFERS = 0x0C00; +enum uint GL_INDEX_CLEAR_VALUE = 0x0C20; +enum uint GL_INDEX_WRITEMASK = 0x0C21; +enum uint GL_INDEX_MODE = 0x0C30; +enum uint GL_RGBA_MODE = 0x0C31; +enum uint GL_RENDER_MODE = 0x0C40; +enum uint GL_PERSPECTIVE_CORRECTION_HINT = 0x0C50; +enum uint GL_POINT_SMOOTH_HINT = 0x0C51; +enum uint GL_FOG_HINT = 0x0C54; +enum uint GL_TEXTURE_GEN_S = 0x0C60; +enum uint GL_TEXTURE_GEN_T = 0x0C61; +enum uint GL_TEXTURE_GEN_R = 0x0C62; +enum uint GL_TEXTURE_GEN_Q = 0x0C63; +enum uint GL_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0; +enum uint GL_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1; +enum uint GL_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2; +enum uint GL_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3; +enum uint GL_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4; +enum uint GL_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5; +enum uint GL_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6; +enum uint GL_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7; +enum uint GL_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8; +enum uint GL_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9; +enum uint GL_MAP_COLOR = 0x0D10; +enum uint GL_MAP_STENCIL = 0x0D11; +enum uint GL_INDEX_SHIFT = 0x0D12; +enum uint GL_INDEX_OFFSET = 0x0D13; +enum uint GL_RED_SCALE = 0x0D14; +enum uint GL_RED_BIAS = 0x0D15; +enum uint GL_ZOOM_X = 0x0D16; +enum uint GL_ZOOM_Y = 0x0D17; +enum uint GL_GREEN_SCALE = 0x0D18; +enum uint GL_GREEN_BIAS = 0x0D19; +enum uint GL_BLUE_SCALE = 0x0D1A; +enum uint GL_BLUE_BIAS = 0x0D1B; +enum uint GL_ALPHA_SCALE = 0x0D1C; +enum uint GL_ALPHA_BIAS = 0x0D1D; +enum uint GL_DEPTH_SCALE = 0x0D1E; +enum uint GL_DEPTH_BIAS = 0x0D1F; +enum uint GL_MAX_EVAL_ORDER = 0x0D30; +enum uint GL_MAX_LIGHTS = 0x0D31; +enum uint GL_MAX_CLIP_PLANES = 0x0D32; +enum uint GL_MAX_PIXEL_MAP_TABLE = 0x0D34; +enum uint GL_MAX_ATTRIB_STACK_DEPTH = 0x0D35; +enum uint GL_MAX_MODELVIEW_STACK_DEPTH = 0x0D36; +enum uint GL_MAX_NAME_STACK_DEPTH = 0x0D37; +enum uint GL_MAX_PROJECTION_STACK_DEPTH = 0x0D38; +enum uint GL_MAX_TEXTURE_STACK_DEPTH = 0x0D39; +enum uint GL_INDEX_BITS = 0x0D51; +enum uint GL_RED_BITS = 0x0D52; +enum uint GL_GREEN_BITS = 0x0D53; +enum uint GL_BLUE_BITS = 0x0D54; +enum uint GL_ALPHA_BITS = 0x0D55; +enum uint GL_DEPTH_BITS = 0x0D56; +enum uint GL_STENCIL_BITS = 0x0D57; +enum uint GL_ACCUM_RED_BITS = 0x0D58; +enum uint GL_ACCUM_GREEN_BITS = 0x0D59; +enum uint GL_ACCUM_BLUE_BITS = 0x0D5A; +enum uint GL_ACCUM_ALPHA_BITS = 0x0D5B; +enum uint GL_NAME_STACK_DEPTH = 0x0D70; +enum uint GL_AUTO_NORMAL = 0x0D80; +enum uint GL_MAP1_COLOR_4 = 0x0D90; +enum uint GL_MAP1_INDEX = 0x0D91; +enum uint GL_MAP1_NORMAL = 0x0D92; +enum uint GL_MAP1_TEXTURE_COORD_1 = 0x0D93; +enum uint GL_MAP1_TEXTURE_COORD_2 = 0x0D94; +enum uint GL_MAP1_TEXTURE_COORD_3 = 0x0D95; +enum uint GL_MAP1_TEXTURE_COORD_4 = 0x0D96; +enum uint GL_MAP1_VERTEX_3 = 0x0D97; +enum uint GL_MAP1_VERTEX_4 = 0x0D98; +enum uint GL_MAP2_COLOR_4 = 0x0DB0; +enum uint GL_MAP2_INDEX = 0x0DB1; +enum uint GL_MAP2_NORMAL = 0x0DB2; +enum uint GL_MAP2_TEXTURE_COORD_1 = 0x0DB3; +enum uint GL_MAP2_TEXTURE_COORD_2 = 0x0DB4; +enum uint GL_MAP2_TEXTURE_COORD_3 = 0x0DB5; +enum uint GL_MAP2_TEXTURE_COORD_4 = 0x0DB6; +enum uint GL_MAP2_VERTEX_3 = 0x0DB7; +enum uint GL_MAP2_VERTEX_4 = 0x0DB8; +enum uint GL_MAP1_GRID_DOMAIN = 0x0DD0; +enum uint GL_MAP1_GRID_SEGMENTS = 0x0DD1; +enum uint GL_MAP2_GRID_DOMAIN = 0x0DD2; +enum uint GL_MAP2_GRID_SEGMENTS = 0x0DD3; +enum uint GL_TEXTURE_COMPONENTS = 0x1003; +enum uint GL_TEXTURE_BORDER = 0x1005; +enum uint GL_AMBIENT = 0x1200; +enum uint GL_DIFFUSE = 0x1201; +enum uint GL_SPECULAR = 0x1202; +enum uint GL_POSITION = 0x1203; +enum uint GL_SPOT_DIRECTION = 0x1204; +enum uint GL_SPOT_EXPONENT = 0x1205; +enum uint GL_SPOT_CUTOFF = 0x1206; +enum uint GL_CONSTANT_ATTENUATION = 0x1207; +enum uint GL_LINEAR_ATTENUATION = 0x1208; +enum uint GL_QUADRATIC_ATTENUATION = 0x1209; +enum uint GL_COMPILE = 0x1300; +enum uint GL_COMPILE_AND_EXECUTE = 0x1301; +enum uint GL_2_BYTES = 0x1407; +enum uint GL_3_BYTES = 0x1408; +enum uint GL_4_BYTES = 0x1409; +enum uint GL_EMISSION = 0x1600; +enum uint GL_SHININESS = 0x1601; +enum uint GL_AMBIENT_AND_DIFFUSE = 0x1602; +enum uint GL_COLOR_INDEXES = 0x1603; +enum uint GL_MODELVIEW = 0x1700; +enum uint GL_PROJECTION = 0x1701; +enum uint GL_COLOR_INDEX = 0x1900; +enum uint GL_LUMINANCE = 0x1909; +enum uint GL_LUMINANCE_ALPHA = 0x190A; +enum uint GL_BITMAP = 0x1A00; +enum uint GL_RENDER = 0x1C00; +enum uint GL_FEEDBACK = 0x1C01; +enum uint GL_SELECT = 0x1C02; +enum uint GL_FLAT = 0x1D00; +enum uint GL_SMOOTH = 0x1D01; +enum uint GL_S = 0x2000; +enum uint GL_T = 0x2001; +enum uint GL_R = 0x2002; +enum uint GL_Q = 0x2003; +enum uint GL_MODULATE = 0x2100; +enum uint GL_DECAL = 0x2101; +enum uint GL_TEXTURE_ENV_MODE = 0x2200; +enum uint GL_TEXTURE_ENV_COLOR = 0x2201; +enum uint GL_TEXTURE_ENV = 0x2300; +enum uint GL_EYE_LINEAR = 0x2400; +enum uint GL_OBJECT_LINEAR = 0x2401; +enum uint GL_SPHERE_MAP = 0x2402; +enum uint GL_TEXTURE_GEN_MODE = 0x2500; +enum uint GL_OBJECT_PLANE = 0x2501; +enum uint GL_EYE_PLANE = 0x2502; +enum uint GL_CLAMP = 0x2900; +enum uint GL_CLIP_PLANE0 = 0x3000; +enum uint GL_CLIP_PLANE1 = 0x3001; +enum uint GL_CLIP_PLANE2 = 0x3002; +enum uint GL_CLIP_PLANE3 = 0x3003; +enum uint GL_CLIP_PLANE4 = 0x3004; +enum uint GL_CLIP_PLANE5 = 0x3005; +enum uint GL_LIGHT0 = 0x4000; +enum uint GL_LIGHT1 = 0x4001; +enum uint GL_LIGHT2 = 0x4002; +enum uint GL_LIGHT3 = 0x4003; +enum uint GL_LIGHT4 = 0x4004; +enum uint GL_LIGHT5 = 0x4005; +enum uint GL_LIGHT6 = 0x4006; +enum uint GL_LIGHT7 = 0x4007; +enum uint GL_COLOR_LOGIC_OP = 0x0BF2; +enum uint GL_POLYGON_OFFSET_UNITS = 0x2A00; +enum uint GL_POLYGON_OFFSET_POINT = 0x2A01; +enum uint GL_POLYGON_OFFSET_LINE = 0x2A02; +enum uint GL_POLYGON_OFFSET_FILL = 0x8037; +enum uint GL_POLYGON_OFFSET_FACTOR = 0x8038; +enum uint GL_TEXTURE_BINDING_1D = 0x8068; +enum uint GL_TEXTURE_BINDING_2D = 0x8069; +enum uint GL_TEXTURE_INTERNAL_FORMAT = 0x1003; +enum uint GL_TEXTURE_RED_SIZE = 0x805C; +enum uint GL_TEXTURE_GREEN_SIZE = 0x805D; +enum uint GL_TEXTURE_BLUE_SIZE = 0x805E; +enum uint GL_TEXTURE_ALPHA_SIZE = 0x805F; +enum uint GL_DOUBLE = 0x140A; +enum uint GL_PROXY_TEXTURE_1D = 0x8063; +enum uint GL_PROXY_TEXTURE_2D = 0x8064; +enum uint GL_R3_G3_B2 = 0x2A10; +enum uint GL_RGB4 = 0x804F; +enum uint GL_RGB5 = 0x8050; +enum uint GL_RGB8 = 0x8051; +enum uint GL_RGB10 = 0x8052; +enum uint GL_RGB12 = 0x8053; +enum uint GL_RGB16 = 0x8054; +enum uint GL_RGBA2 = 0x8055; +enum uint GL_RGBA4 = 0x8056; +enum uint GL_RGB5_A1 = 0x8057; +enum uint GL_RGBA8 = 0x8058; +enum uint GL_RGB10_A2 = 0x8059; +enum uint GL_RGBA12 = 0x805A; +enum uint GL_RGBA16 = 0x805B; +enum uint GL_CLIENT_PIXEL_STORE_BIT = 0x00000001; +enum uint GL_CLIENT_VERTEX_ARRAY_BIT = 0x00000002; +enum uint GL_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF; +enum uint GL_VERTEX_ARRAY_POINTER = 0x808E; +enum uint GL_NORMAL_ARRAY_POINTER = 0x808F; +enum uint GL_COLOR_ARRAY_POINTER = 0x8090; +enum uint GL_INDEX_ARRAY_POINTER = 0x8091; +enum uint GL_TEXTURE_COORD_ARRAY_POINTER = 0x8092; +enum uint GL_EDGE_FLAG_ARRAY_POINTER = 0x8093; +enum uint GL_FEEDBACK_BUFFER_POINTER = 0x0DF0; +enum uint GL_SELECTION_BUFFER_POINTER = 0x0DF3; +enum uint GL_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1; +enum uint GL_INDEX_LOGIC_OP = 0x0BF1; +enum uint GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B; +enum uint GL_FEEDBACK_BUFFER_SIZE = 0x0DF1; +enum uint GL_FEEDBACK_BUFFER_TYPE = 0x0DF2; +enum uint GL_SELECTION_BUFFER_SIZE = 0x0DF4; +enum uint GL_VERTEX_ARRAY = 0x8074; +enum uint GL_NORMAL_ARRAY = 0x8075; +enum uint GL_COLOR_ARRAY = 0x8076; +enum uint GL_INDEX_ARRAY = 0x8077; +enum uint GL_TEXTURE_COORD_ARRAY = 0x8078; +enum uint GL_EDGE_FLAG_ARRAY = 0x8079; +enum uint GL_VERTEX_ARRAY_SIZE = 0x807A; +enum uint GL_VERTEX_ARRAY_TYPE = 0x807B; +enum uint GL_VERTEX_ARRAY_STRIDE = 0x807C; +enum uint GL_NORMAL_ARRAY_TYPE = 0x807E; +enum uint GL_NORMAL_ARRAY_STRIDE = 0x807F; +enum uint GL_COLOR_ARRAY_SIZE = 0x8081; +enum uint GL_COLOR_ARRAY_TYPE = 0x8082; +enum uint GL_COLOR_ARRAY_STRIDE = 0x8083; +enum uint GL_INDEX_ARRAY_TYPE = 0x8085; +enum uint GL_INDEX_ARRAY_STRIDE = 0x8086; +enum uint GL_TEXTURE_COORD_ARRAY_SIZE = 0x8088; +enum uint GL_TEXTURE_COORD_ARRAY_TYPE = 0x8089; +enum uint GL_TEXTURE_COORD_ARRAY_STRIDE = 0x808A; +enum uint GL_EDGE_FLAG_ARRAY_STRIDE = 0x808C; +enum uint GL_TEXTURE_LUMINANCE_SIZE = 0x8060; +enum uint GL_TEXTURE_INTENSITY_SIZE = 0x8061; +enum uint GL_TEXTURE_PRIORITY = 0x8066; +enum uint GL_TEXTURE_RESIDENT = 0x8067; +enum uint GL_ALPHA4 = 0x803B; +enum uint GL_ALPHA8 = 0x803C; +enum uint GL_ALPHA12 = 0x803D; +enum uint GL_ALPHA16 = 0x803E; +enum uint GL_LUMINANCE4 = 0x803F; +enum uint GL_LUMINANCE8 = 0x8040; +enum uint GL_LUMINANCE12 = 0x8041; +enum uint GL_LUMINANCE16 = 0x8042; +enum uint GL_LUMINANCE4_ALPHA4 = 0x8043; +enum uint GL_LUMINANCE6_ALPHA2 = 0x8044; +enum uint GL_LUMINANCE8_ALPHA8 = 0x8045; +enum uint GL_LUMINANCE12_ALPHA4 = 0x8046; +enum uint GL_LUMINANCE12_ALPHA12 = 0x8047; +enum uint GL_LUMINANCE16_ALPHA16 = 0x8048; +enum uint GL_INTENSITY = 0x8049; +enum uint GL_INTENSITY4 = 0x804A; +enum uint GL_INTENSITY8 = 0x804B; +enum uint GL_INTENSITY12 = 0x804C; +enum uint GL_INTENSITY16 = 0x804D; +enum uint GL_V2F = 0x2A20; +enum uint GL_V3F = 0x2A21; +enum uint GL_C4UB_V2F = 0x2A22; +enum uint GL_C4UB_V3F = 0x2A23; +enum uint GL_C3F_V3F = 0x2A24; +enum uint GL_N3F_V3F = 0x2A25; +enum uint GL_C4F_N3F_V3F = 0x2A26; +enum uint GL_T2F_V3F = 0x2A27; +enum uint GL_T4F_V4F = 0x2A28; +enum uint GL_T2F_C4UB_V3F = 0x2A29; +enum uint GL_T2F_C3F_V3F = 0x2A2A; +enum uint GL_T2F_N3F_V3F = 0x2A2B; +enum uint GL_T2F_C4F_N3F_V3F = 0x2A2C; +enum uint GL_T4F_C4F_N3F_V4F = 0x2A2D; +enum uint GL_UNSIGNED_BYTE_3_3_2 = 0x8032; +enum uint GL_UNSIGNED_SHORT_4_4_4_4 = 0x8033; +enum uint GL_UNSIGNED_SHORT_5_5_5_1 = 0x8034; +enum uint GL_UNSIGNED_INT_8_8_8_8 = 0x8035; +enum uint GL_UNSIGNED_INT_10_10_10_2 = 0x8036; +enum uint GL_TEXTURE_BINDING_3D = 0x806A; +enum uint GL_PACK_SKIP_IMAGES = 0x806B; +enum uint GL_PACK_IMAGE_HEIGHT = 0x806C; +enum uint GL_UNPACK_SKIP_IMAGES = 0x806D; +enum uint GL_UNPACK_IMAGE_HEIGHT = 0x806E; +enum uint GL_TEXTURE_3D = 0x806F; +enum uint GL_PROXY_TEXTURE_3D = 0x8070; +enum uint GL_TEXTURE_DEPTH = 0x8071; +enum uint GL_TEXTURE_WRAP_R = 0x8072; +enum uint GL_MAX_3D_TEXTURE_SIZE = 0x8073; +enum uint GL_UNSIGNED_BYTE_2_3_3_REV = 0x8362; +enum uint GL_UNSIGNED_SHORT_5_6_5 = 0x8363; +enum uint GL_UNSIGNED_SHORT_5_6_5_REV = 0x8364; +enum uint GL_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365; +enum uint GL_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366; +enum uint GL_UNSIGNED_INT_8_8_8_8_REV = 0x8367; +enum uint GL_UNSIGNED_INT_2_10_10_10_REV = 0x8368; +enum uint GL_BGR = 0x80E0; +enum uint GL_BGRA = 0x80E1; +enum uint GL_MAX_ELEMENTS_VERTICES = 0x80E8; +enum uint GL_MAX_ELEMENTS_INDICES = 0x80E9; +enum uint GL_CLAMP_TO_EDGE = 0x812F; +enum uint GL_TEXTURE_MIN_LOD = 0x813A; +enum uint GL_TEXTURE_MAX_LOD = 0x813B; +enum uint GL_TEXTURE_BASE_LEVEL = 0x813C; +enum uint GL_TEXTURE_MAX_LEVEL = 0x813D; +enum uint GL_SMOOTH_POINT_SIZE_RANGE = 0x0B12; +enum uint GL_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13; +enum uint GL_SMOOTH_LINE_WIDTH_RANGE = 0x0B22; +enum uint GL_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23; +enum uint GL_ALIASED_LINE_WIDTH_RANGE = 0x846E; +enum uint GL_RESCALE_NORMAL = 0x803A; +enum uint GL_LIGHT_MODEL_COLOR_CONTROL = 0x81F8; +enum uint GL_SINGLE_COLOR = 0x81F9; +enum uint GL_SEPARATE_SPECULAR_COLOR = 0x81FA; +enum uint GL_ALIASED_POINT_SIZE_RANGE = 0x846D; +enum uint GL_TEXTURE0 = 0x84C0; +enum uint GL_TEXTURE1 = 0x84C1; +enum uint GL_TEXTURE2 = 0x84C2; +enum uint GL_TEXTURE3 = 0x84C3; +enum uint GL_TEXTURE4 = 0x84C4; +enum uint GL_TEXTURE5 = 0x84C5; +enum uint GL_TEXTURE6 = 0x84C6; +enum uint GL_TEXTURE7 = 0x84C7; +enum uint GL_TEXTURE8 = 0x84C8; +enum uint GL_TEXTURE9 = 0x84C9; +enum uint GL_TEXTURE10 = 0x84CA; +enum uint GL_TEXTURE11 = 0x84CB; +enum uint GL_TEXTURE12 = 0x84CC; +enum uint GL_TEXTURE13 = 0x84CD; +enum uint GL_TEXTURE14 = 0x84CE; +enum uint GL_TEXTURE15 = 0x84CF; +enum uint GL_TEXTURE16 = 0x84D0; +enum uint GL_TEXTURE17 = 0x84D1; +enum uint GL_TEXTURE18 = 0x84D2; +enum uint GL_TEXTURE19 = 0x84D3; +enum uint GL_TEXTURE20 = 0x84D4; +enum uint GL_TEXTURE21 = 0x84D5; +enum uint GL_TEXTURE22 = 0x84D6; +enum uint GL_TEXTURE23 = 0x84D7; +enum uint GL_TEXTURE24 = 0x84D8; +enum uint GL_TEXTURE25 = 0x84D9; +enum uint GL_TEXTURE26 = 0x84DA; +enum uint GL_TEXTURE27 = 0x84DB; +enum uint GL_TEXTURE28 = 0x84DC; +enum uint GL_TEXTURE29 = 0x84DD; +enum uint GL_TEXTURE30 = 0x84DE; +enum uint GL_TEXTURE31 = 0x84DF; +enum uint GL_ACTIVE_TEXTURE = 0x84E0; +enum uint GL_MULTISAMPLE = 0x809D; +enum uint GL_SAMPLE_ALPHA_TO_COVERAGE = 0x809E; +enum uint GL_SAMPLE_ALPHA_TO_ONE = 0x809F; +enum uint GL_SAMPLE_COVERAGE = 0x80A0; +enum uint GL_SAMPLE_BUFFERS = 0x80A8; +enum uint GL_SAMPLES = 0x80A9; +enum uint GL_SAMPLE_COVERAGE_VALUE = 0x80AA; +enum uint GL_SAMPLE_COVERAGE_INVERT = 0x80AB; +enum uint GL_TEXTURE_CUBE_MAP = 0x8513; +enum uint GL_TEXTURE_BINDING_CUBE_MAP = 0x8514; +enum uint GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515; +enum uint GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516; +enum uint GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517; +enum uint GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518; +enum uint GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519; +enum uint GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A; +enum uint GL_PROXY_TEXTURE_CUBE_MAP = 0x851B; +enum uint GL_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C; +enum uint GL_COMPRESSED_RGB = 0x84ED; +enum uint GL_COMPRESSED_RGBA = 0x84EE; +enum uint GL_TEXTURE_COMPRESSION_HINT = 0x84EF; +enum uint GL_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0; +enum uint GL_TEXTURE_COMPRESSED = 0x86A1; +enum uint GL_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2; +enum uint GL_COMPRESSED_TEXTURE_FORMATS = 0x86A3; +enum uint GL_CLAMP_TO_BORDER = 0x812D; +enum uint GL_CLIENT_ACTIVE_TEXTURE = 0x84E1; +enum uint GL_MAX_TEXTURE_UNITS = 0x84E2; +enum uint GL_TRANSPOSE_MODELVIEW_MATRIX = 0x84E3; +enum uint GL_TRANSPOSE_PROJECTION_MATRIX = 0x84E4; +enum uint GL_TRANSPOSE_TEXTURE_MATRIX = 0x84E5; +enum uint GL_TRANSPOSE_COLOR_MATRIX = 0x84E6; +enum uint GL_MULTISAMPLE_BIT = 0x20000000; +enum uint GL_NORMAL_MAP = 0x8511; +enum uint GL_REFLECTION_MAP = 0x8512; +enum uint GL_COMPRESSED_ALPHA = 0x84E9; +enum uint GL_COMPRESSED_LUMINANCE = 0x84EA; +enum uint GL_COMPRESSED_LUMINANCE_ALPHA = 0x84EB; +enum uint GL_COMPRESSED_INTENSITY = 0x84EC; +enum uint GL_COMBINE = 0x8570; +enum uint GL_COMBINE_RGB = 0x8571; +enum uint GL_COMBINE_ALPHA = 0x8572; +enum uint GL_SOURCE0_RGB = 0x8580; +enum uint GL_SOURCE1_RGB = 0x8581; +enum uint GL_SOURCE2_RGB = 0x8582; +enum uint GL_SOURCE0_ALPHA = 0x8588; +enum uint GL_SOURCE1_ALPHA = 0x8589; +enum uint GL_SOURCE2_ALPHA = 0x858A; +enum uint GL_OPERAND0_RGB = 0x8590; +enum uint GL_OPERAND1_RGB = 0x8591; +enum uint GL_OPERAND2_RGB = 0x8592; +enum uint GL_OPERAND0_ALPHA = 0x8598; +enum uint GL_OPERAND1_ALPHA = 0x8599; +enum uint GL_OPERAND2_ALPHA = 0x859A; +enum uint GL_RGB_SCALE = 0x8573; +enum uint GL_ADD_SIGNED = 0x8574; +enum uint GL_INTERPOLATE = 0x8575; +enum uint GL_SUBTRACT = 0x84E7; +enum uint GL_CONSTANT = 0x8576; +enum uint GL_PRIMARY_COLOR = 0x8577; +enum uint GL_PREVIOUS = 0x8578; +enum uint GL_DOT3_RGB = 0x86AE; +enum uint GL_DOT3_RGBA = 0x86AF; +enum uint GL_BLEND_DST_RGB = 0x80C8; +enum uint GL_BLEND_SRC_RGB = 0x80C9; +enum uint GL_BLEND_DST_ALPHA = 0x80CA; +enum uint GL_BLEND_SRC_ALPHA = 0x80CB; +enum uint GL_POINT_FADE_THRESHOLD_SIZE = 0x8128; +enum uint GL_DEPTH_COMPONENT16 = 0x81A5; +enum uint GL_DEPTH_COMPONENT24 = 0x81A6; +enum uint GL_DEPTH_COMPONENT32 = 0x81A7; +enum uint GL_MIRRORED_REPEAT = 0x8370; +enum uint GL_MAX_TEXTURE_LOD_BIAS = 0x84FD; +enum uint GL_TEXTURE_LOD_BIAS = 0x8501; +enum uint GL_INCR_WRAP = 0x8507; +enum uint GL_DECR_WRAP = 0x8508; +enum uint GL_TEXTURE_DEPTH_SIZE = 0x884A; +enum uint GL_TEXTURE_COMPARE_MODE = 0x884C; +enum uint GL_TEXTURE_COMPARE_FUNC = 0x884D; +enum uint GL_POINT_SIZE_MIN = 0x8126; +enum uint GL_POINT_SIZE_MAX = 0x8127; +enum uint GL_POINT_DISTANCE_ATTENUATION = 0x8129; +enum uint GL_GENERATE_MIPMAP = 0x8191; +enum uint GL_GENERATE_MIPMAP_HINT = 0x8192; +enum uint GL_FOG_COORDINATE_SOURCE = 0x8450; +enum uint GL_FOG_COORDINATE = 0x8451; +enum uint GL_FRAGMENT_DEPTH = 0x8452; +enum uint GL_CURRENT_FOG_COORDINATE = 0x8453; +enum uint GL_FOG_COORDINATE_ARRAY_TYPE = 0x8454; +enum uint GL_FOG_COORDINATE_ARRAY_STRIDE = 0x8455; +enum uint GL_FOG_COORDINATE_ARRAY_POINTER = 0x8456; +enum uint GL_FOG_COORDINATE_ARRAY = 0x8457; +enum uint GL_COLOR_SUM = 0x8458; +enum uint GL_CURRENT_SECONDARY_COLOR = 0x8459; +enum uint GL_SECONDARY_COLOR_ARRAY_SIZE = 0x845A; +enum uint GL_SECONDARY_COLOR_ARRAY_TYPE = 0x845B; +enum uint GL_SECONDARY_COLOR_ARRAY_STRIDE = 0x845C; +enum uint GL_SECONDARY_COLOR_ARRAY_POINTER = 0x845D; +enum uint GL_SECONDARY_COLOR_ARRAY = 0x845E; +enum uint GL_TEXTURE_FILTER_CONTROL = 0x8500; +enum uint GL_DEPTH_TEXTURE_MODE = 0x884B; +enum uint GL_COMPARE_R_TO_TEXTURE = 0x884E; +enum uint GL_BLEND_COLOR = 0x8005; +enum uint GL_BLEND_EQUATION = 0x8009; +enum uint GL_CONSTANT_COLOR = 0x8001; +enum uint GL_ONE_MINUS_CONSTANT_COLOR = 0x8002; +enum uint GL_CONSTANT_ALPHA = 0x8003; +enum uint GL_ONE_MINUS_CONSTANT_ALPHA = 0x8004; +enum uint GL_FUNC_ADD = 0x8006; +enum uint GL_FUNC_REVERSE_SUBTRACT = 0x800B; +enum uint GL_FUNC_SUBTRACT = 0x800A; +enum uint GL_MIN = 0x8007; +enum uint GL_MAX = 0x8008; +enum uint GL_BUFFER_SIZE = 0x8764; +enum uint GL_BUFFER_USAGE = 0x8765; +enum uint GL_QUERY_COUNTER_BITS = 0x8864; +enum uint GL_CURRENT_QUERY = 0x8865; +enum uint GL_QUERY_RESULT = 0x8866; +enum uint GL_QUERY_RESULT_AVAILABLE = 0x8867; +enum uint GL_ARRAY_BUFFER = 0x8892; +enum uint GL_ELEMENT_ARRAY_BUFFER = 0x8893; +enum uint GL_ARRAY_BUFFER_BINDING = 0x8894; +enum uint GL_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895; +enum uint GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F; +enum uint GL_READ_ONLY = 0x88B8; +enum uint GL_WRITE_ONLY = 0x88B9; +enum uint GL_READ_WRITE = 0x88BA; +enum uint GL_BUFFER_ACCESS = 0x88BB; +enum uint GL_BUFFER_MAPPED = 0x88BC; +enum uint GL_BUFFER_MAP_POINTER = 0x88BD; +enum uint GL_STREAM_DRAW = 0x88E0; +enum uint GL_STREAM_READ = 0x88E1; +enum uint GL_STREAM_COPY = 0x88E2; +enum uint GL_STATIC_DRAW = 0x88E4; +enum uint GL_STATIC_READ = 0x88E5; +enum uint GL_STATIC_COPY = 0x88E6; +enum uint GL_DYNAMIC_DRAW = 0x88E8; +enum uint GL_DYNAMIC_READ = 0x88E9; +enum uint GL_DYNAMIC_COPY = 0x88EA; +enum uint GL_SAMPLES_PASSED = 0x8914; +enum uint GL_SRC1_ALPHA = 0x8589; +enum uint GL_VERTEX_ARRAY_BUFFER_BINDING = 0x8896; +enum uint GL_NORMAL_ARRAY_BUFFER_BINDING = 0x8897; +enum uint GL_COLOR_ARRAY_BUFFER_BINDING = 0x8898; +enum uint GL_INDEX_ARRAY_BUFFER_BINDING = 0x8899; +enum uint GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A; +enum uint GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B; +enum uint GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C; +enum uint GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D; +enum uint GL_WEIGHT_ARRAY_BUFFER_BINDING = 0x889E; +enum uint GL_FOG_COORD_SRC = 0x8450; +enum uint GL_FOG_COORD = 0x8451; +enum uint GL_CURRENT_FOG_COORD = 0x8453; +enum uint GL_FOG_COORD_ARRAY_TYPE = 0x8454; +enum uint GL_FOG_COORD_ARRAY_STRIDE = 0x8455; +enum uint GL_FOG_COORD_ARRAY_POINTER = 0x8456; +enum uint GL_FOG_COORD_ARRAY = 0x8457; +enum uint GL_FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D; +enum uint GL_SRC0_RGB = 0x8580; +enum uint GL_SRC1_RGB = 0x8581; +enum uint GL_SRC2_RGB = 0x8582; +enum uint GL_SRC0_ALPHA = 0x8588; +enum uint GL_SRC2_ALPHA = 0x858A; +enum uint GL_BLEND_EQUATION_RGB = 0x8009; +enum uint GL_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622; +enum uint GL_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623; +enum uint GL_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624; +enum uint GL_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625; +enum uint GL_CURRENT_VERTEX_ATTRIB = 0x8626; +enum uint GL_VERTEX_PROGRAM_POINT_SIZE = 0x8642; +enum uint GL_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645; +enum uint GL_STENCIL_BACK_FUNC = 0x8800; +enum uint GL_STENCIL_BACK_FAIL = 0x8801; +enum uint GL_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802; +enum uint GL_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803; +enum uint GL_MAX_DRAW_BUFFERS = 0x8824; +enum uint GL_DRAW_BUFFER0 = 0x8825; +enum uint GL_DRAW_BUFFER1 = 0x8826; +enum uint GL_DRAW_BUFFER2 = 0x8827; +enum uint GL_DRAW_BUFFER3 = 0x8828; +enum uint GL_DRAW_BUFFER4 = 0x8829; +enum uint GL_DRAW_BUFFER5 = 0x882A; +enum uint GL_DRAW_BUFFER6 = 0x882B; +enum uint GL_DRAW_BUFFER7 = 0x882C; +enum uint GL_DRAW_BUFFER8 = 0x882D; +enum uint GL_DRAW_BUFFER9 = 0x882E; +enum uint GL_DRAW_BUFFER10 = 0x882F; +enum uint GL_DRAW_BUFFER11 = 0x8830; +enum uint GL_DRAW_BUFFER12 = 0x8831; +enum uint GL_DRAW_BUFFER13 = 0x8832; +enum uint GL_DRAW_BUFFER14 = 0x8833; +enum uint GL_DRAW_BUFFER15 = 0x8834; +enum uint GL_BLEND_EQUATION_ALPHA = 0x883D; +enum uint GL_MAX_VERTEX_ATTRIBS = 0x8869; +enum uint GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A; +enum uint GL_MAX_TEXTURE_IMAGE_UNITS = 0x8872; +enum uint GL_FRAGMENT_SHADER = 0x8B30; +enum uint GL_VERTEX_SHADER = 0x8B31; +enum uint GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49; +enum uint GL_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A; +enum uint GL_MAX_VARYING_FLOATS = 0x8B4B; +enum uint GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C; +enum uint GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D; +enum uint GL_SHADER_TYPE = 0x8B4F; +enum uint GL_FLOAT_VEC2 = 0x8B50; +enum uint GL_FLOAT_VEC3 = 0x8B51; +enum uint GL_FLOAT_VEC4 = 0x8B52; +enum uint GL_INT_VEC2 = 0x8B53; +enum uint GL_INT_VEC3 = 0x8B54; +enum uint GL_INT_VEC4 = 0x8B55; +enum uint GL_BOOL = 0x8B56; +enum uint GL_BOOL_VEC2 = 0x8B57; +enum uint GL_BOOL_VEC3 = 0x8B58; +enum uint GL_BOOL_VEC4 = 0x8B59; +enum uint GL_FLOAT_MAT2 = 0x8B5A; +enum uint GL_FLOAT_MAT3 = 0x8B5B; +enum uint GL_FLOAT_MAT4 = 0x8B5C; +enum uint GL_SAMPLER_1D = 0x8B5D; +enum uint GL_SAMPLER_2D = 0x8B5E; +enum uint GL_SAMPLER_3D = 0x8B5F; +enum uint GL_SAMPLER_CUBE = 0x8B60; +enum uint GL_SAMPLER_1D_SHADOW = 0x8B61; +enum uint GL_SAMPLER_2D_SHADOW = 0x8B62; +enum uint GL_DELETE_STATUS = 0x8B80; +enum uint GL_COMPILE_STATUS = 0x8B81; +enum uint GL_LINK_STATUS = 0x8B82; +enum uint GL_VALIDATE_STATUS = 0x8B83; +enum uint GL_INFO_LOG_LENGTH = 0x8B84; +enum uint GL_ATTACHED_SHADERS = 0x8B85; +enum uint GL_ACTIVE_UNIFORMS = 0x8B86; +enum uint GL_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87; +enum uint GL_SHADER_SOURCE_LENGTH = 0x8B88; +enum uint GL_ACTIVE_ATTRIBUTES = 0x8B89; +enum uint GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A; +enum uint GL_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B; +enum uint GL_SHADING_LANGUAGE_VERSION = 0x8B8C; +enum uint GL_CURRENT_PROGRAM = 0x8B8D; +enum uint GL_POINT_SPRITE_COORD_ORIGIN = 0x8CA0; +enum uint GL_LOWER_LEFT = 0x8CA1; +enum uint GL_UPPER_LEFT = 0x8CA2; +enum uint GL_STENCIL_BACK_REF = 0x8CA3; +enum uint GL_STENCIL_BACK_VALUE_MASK = 0x8CA4; +enum uint GL_STENCIL_BACK_WRITEMASK = 0x8CA5; +enum uint GL_VERTEX_PROGRAM_TWO_SIDE = 0x8643; +enum uint GL_POINT_SPRITE = 0x8861; +enum uint GL_COORD_REPLACE = 0x8862; +enum uint GL_MAX_TEXTURE_COORDS = 0x8871; +enum uint GL_PIXEL_PACK_BUFFER = 0x88EB; +enum uint GL_PIXEL_UNPACK_BUFFER = 0x88EC; +enum uint GL_PIXEL_PACK_BUFFER_BINDING = 0x88ED; +enum uint GL_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF; +enum uint GL_FLOAT_MAT2x3 = 0x8B65; +enum uint GL_FLOAT_MAT2x4 = 0x8B66; +enum uint GL_FLOAT_MAT3x2 = 0x8B67; +enum uint GL_FLOAT_MAT3x4 = 0x8B68; +enum uint GL_FLOAT_MAT4x2 = 0x8B69; +enum uint GL_FLOAT_MAT4x3 = 0x8B6A; +enum uint GL_SRGB = 0x8C40; +enum uint GL_SRGB8 = 0x8C41; +enum uint GL_SRGB_ALPHA = 0x8C42; +enum uint GL_SRGB8_ALPHA8 = 0x8C43; +enum uint GL_COMPRESSED_SRGB = 0x8C48; +enum uint GL_COMPRESSED_SRGB_ALPHA = 0x8C49; +enum uint GL_CURRENT_RASTER_SECONDARY_COLOR = 0x845F; +enum uint GL_SLUMINANCE_ALPHA = 0x8C44; +enum uint GL_SLUMINANCE8_ALPHA8 = 0x8C45; +enum uint GL_SLUMINANCE = 0x8C46; +enum uint GL_SLUMINANCE8 = 0x8C47; +enum uint GL_COMPRESSED_SLUMINANCE = 0x8C4A; +enum uint GL_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B; +enum uint GL_COMPARE_REF_TO_TEXTURE = 0x884E; +enum uint GL_CLIP_DISTANCE0 = 0x3000; +enum uint GL_CLIP_DISTANCE1 = 0x3001; +enum uint GL_CLIP_DISTANCE2 = 0x3002; +enum uint GL_CLIP_DISTANCE3 = 0x3003; +enum uint GL_CLIP_DISTANCE4 = 0x3004; +enum uint GL_CLIP_DISTANCE5 = 0x3005; +enum uint GL_CLIP_DISTANCE6 = 0x3006; +enum uint GL_CLIP_DISTANCE7 = 0x3007; +enum uint GL_MAX_CLIP_DISTANCES = 0x0D32; +enum uint GL_MAJOR_VERSION = 0x821B; +enum uint GL_MINOR_VERSION = 0x821C; +enum uint GL_NUM_EXTENSIONS = 0x821D; +enum uint GL_CONTEXT_FLAGS = 0x821E; +enum uint GL_COMPRESSED_RED = 0x8225; +enum uint GL_COMPRESSED_RG = 0x8226; +enum uint GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001; +enum uint GL_RGBA32F = 0x8814; +enum uint GL_RGB32F = 0x8815; +enum uint GL_RGBA16F = 0x881A; +enum uint GL_RGB16F = 0x881B; +enum uint GL_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD; +enum uint GL_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF; +enum uint GL_MIN_PROGRAM_TEXEL_OFFSET = 0x8904; +enum uint GL_MAX_PROGRAM_TEXEL_OFFSET = 0x8905; +enum uint GL_CLAMP_READ_COLOR = 0x891C; +enum uint GL_FIXED_ONLY = 0x891D; +enum uint GL_MAX_VARYING_COMPONENTS = 0x8B4B; +enum uint GL_TEXTURE_1D_ARRAY = 0x8C18; +enum uint GL_PROXY_TEXTURE_1D_ARRAY = 0x8C19; +enum uint GL_TEXTURE_2D_ARRAY = 0x8C1A; +enum uint GL_PROXY_TEXTURE_2D_ARRAY = 0x8C1B; +enum uint GL_TEXTURE_BINDING_1D_ARRAY = 0x8C1C; +enum uint GL_TEXTURE_BINDING_2D_ARRAY = 0x8C1D; +enum uint GL_R11F_G11F_B10F = 0x8C3A; +enum uint GL_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B; +enum uint GL_RGB9_E5 = 0x8C3D; +enum uint GL_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E; +enum uint GL_TEXTURE_SHARED_SIZE = 0x8C3F; +enum uint GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F; +enum uint GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80; +enum uint GL_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85; +enum uint GL_PRIMITIVES_GENERATED = 0x8C87; +enum uint GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88; +enum uint GL_RASTERIZER_DISCARD = 0x8C89; +enum uint GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A; +enum uint GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B; +enum uint GL_INTERLEAVED_ATTRIBS = 0x8C8C; +enum uint GL_SEPARATE_ATTRIBS = 0x8C8D; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E; +enum uint GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F; +enum uint GL_RGBA32UI = 0x8D70; +enum uint GL_RGB32UI = 0x8D71; +enum uint GL_RGBA16UI = 0x8D76; +enum uint GL_RGB16UI = 0x8D77; +enum uint GL_RGBA8UI = 0x8D7C; +enum uint GL_RGB8UI = 0x8D7D; +enum uint GL_RGBA32I = 0x8D82; +enum uint GL_RGB32I = 0x8D83; +enum uint GL_RGBA16I = 0x8D88; +enum uint GL_RGB16I = 0x8D89; +enum uint GL_RGBA8I = 0x8D8E; +enum uint GL_RGB8I = 0x8D8F; +enum uint GL_RED_INTEGER = 0x8D94; +enum uint GL_GREEN_INTEGER = 0x8D95; +enum uint GL_BLUE_INTEGER = 0x8D96; +enum uint GL_RGB_INTEGER = 0x8D98; +enum uint GL_RGBA_INTEGER = 0x8D99; +enum uint GL_BGR_INTEGER = 0x8D9A; +enum uint GL_BGRA_INTEGER = 0x8D9B; +enum uint GL_SAMPLER_1D_ARRAY = 0x8DC0; +enum uint GL_SAMPLER_2D_ARRAY = 0x8DC1; +enum uint GL_SAMPLER_1D_ARRAY_SHADOW = 0x8DC3; +enum uint GL_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4; +enum uint GL_SAMPLER_CUBE_SHADOW = 0x8DC5; +enum uint GL_UNSIGNED_INT_VEC2 = 0x8DC6; +enum uint GL_UNSIGNED_INT_VEC3 = 0x8DC7; +enum uint GL_UNSIGNED_INT_VEC4 = 0x8DC8; +enum uint GL_INT_SAMPLER_1D = 0x8DC9; +enum uint GL_INT_SAMPLER_2D = 0x8DCA; +enum uint GL_INT_SAMPLER_3D = 0x8DCB; +enum uint GL_INT_SAMPLER_CUBE = 0x8DCC; +enum uint GL_INT_SAMPLER_1D_ARRAY = 0x8DCE; +enum uint GL_INT_SAMPLER_2D_ARRAY = 0x8DCF; +enum uint GL_UNSIGNED_INT_SAMPLER_1D = 0x8DD1; +enum uint GL_UNSIGNED_INT_SAMPLER_2D = 0x8DD2; +enum uint GL_UNSIGNED_INT_SAMPLER_3D = 0x8DD3; +enum uint GL_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4; +enum uint GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7; +enum uint GL_QUERY_WAIT = 0x8E13; +enum uint GL_QUERY_NO_WAIT = 0x8E14; +enum uint GL_QUERY_BY_REGION_WAIT = 0x8E15; +enum uint GL_QUERY_BY_REGION_NO_WAIT = 0x8E16; +enum uint GL_BUFFER_ACCESS_FLAGS = 0x911F; +enum uint GL_BUFFER_MAP_LENGTH = 0x9120; +enum uint GL_BUFFER_MAP_OFFSET = 0x9121; +enum uint GL_DEPTH_COMPONENT32F = 0x8CAC; +enum uint GL_DEPTH32F_STENCIL8 = 0x8CAD; +enum uint GL_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD; +enum uint GL_INVALID_FRAMEBUFFER_OPERATION = 0x0506; +enum uint GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210; +enum uint GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211; +enum uint GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212; +enum uint GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213; +enum uint GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214; +enum uint GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215; +enum uint GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216; +enum uint GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217; +enum uint GL_FRAMEBUFFER_DEFAULT = 0x8218; +enum uint GL_FRAMEBUFFER_UNDEFINED = 0x8219; +enum uint GL_DEPTH_STENCIL_ATTACHMENT = 0x821A; +enum uint GL_MAX_RENDERBUFFER_SIZE = 0x84E8; +enum uint GL_DEPTH_STENCIL = 0x84F9; +enum uint GL_UNSIGNED_INT_24_8 = 0x84FA; +enum uint GL_DEPTH24_STENCIL8 = 0x88F0; +enum uint GL_TEXTURE_STENCIL_SIZE = 0x88F1; +enum uint GL_TEXTURE_RED_TYPE = 0x8C10; +enum uint GL_TEXTURE_GREEN_TYPE = 0x8C11; +enum uint GL_TEXTURE_BLUE_TYPE = 0x8C12; +enum uint GL_TEXTURE_ALPHA_TYPE = 0x8C13; +enum uint GL_TEXTURE_DEPTH_TYPE = 0x8C16; +enum uint GL_UNSIGNED_NORMALIZED = 0x8C17; +enum uint GL_FRAMEBUFFER_BINDING = 0x8CA6; +enum uint GL_DRAW_FRAMEBUFFER_BINDING = 0x8CA6; +enum uint GL_RENDERBUFFER_BINDING = 0x8CA7; +enum uint GL_READ_FRAMEBUFFER = 0x8CA8; +enum uint GL_DRAW_FRAMEBUFFER = 0x8CA9; +enum uint GL_READ_FRAMEBUFFER_BINDING = 0x8CAA; +enum uint GL_RENDERBUFFER_SAMPLES = 0x8CAB; +enum uint GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0; +enum uint GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1; +enum uint GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2; +enum uint GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3; +enum uint GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4; +enum uint GL_FRAMEBUFFER_COMPLETE = 0x8CD5; +enum uint GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6; +enum uint GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7; +enum uint GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB; +enum uint GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC; +enum uint GL_FRAMEBUFFER_UNSUPPORTED = 0x8CDD; +enum uint GL_MAX_COLOR_ATTACHMENTS = 0x8CDF; +enum uint GL_COLOR_ATTACHMENT0 = 0x8CE0; +enum uint GL_COLOR_ATTACHMENT1 = 0x8CE1; +enum uint GL_COLOR_ATTACHMENT2 = 0x8CE2; +enum uint GL_COLOR_ATTACHMENT3 = 0x8CE3; +enum uint GL_COLOR_ATTACHMENT4 = 0x8CE4; +enum uint GL_COLOR_ATTACHMENT5 = 0x8CE5; +enum uint GL_COLOR_ATTACHMENT6 = 0x8CE6; +enum uint GL_COLOR_ATTACHMENT7 = 0x8CE7; +enum uint GL_COLOR_ATTACHMENT8 = 0x8CE8; +enum uint GL_COLOR_ATTACHMENT9 = 0x8CE9; +enum uint GL_COLOR_ATTACHMENT10 = 0x8CEA; +enum uint GL_COLOR_ATTACHMENT11 = 0x8CEB; +enum uint GL_COLOR_ATTACHMENT12 = 0x8CEC; +enum uint GL_COLOR_ATTACHMENT13 = 0x8CED; +enum uint GL_COLOR_ATTACHMENT14 = 0x8CEE; +enum uint GL_COLOR_ATTACHMENT15 = 0x8CEF; +enum uint GL_COLOR_ATTACHMENT16 = 0x8CF0; +enum uint GL_COLOR_ATTACHMENT17 = 0x8CF1; +enum uint GL_COLOR_ATTACHMENT18 = 0x8CF2; +enum uint GL_COLOR_ATTACHMENT19 = 0x8CF3; +enum uint GL_COLOR_ATTACHMENT20 = 0x8CF4; +enum uint GL_COLOR_ATTACHMENT21 = 0x8CF5; +enum uint GL_COLOR_ATTACHMENT22 = 0x8CF6; +enum uint GL_COLOR_ATTACHMENT23 = 0x8CF7; +enum uint GL_COLOR_ATTACHMENT24 = 0x8CF8; +enum uint GL_COLOR_ATTACHMENT25 = 0x8CF9; +enum uint GL_COLOR_ATTACHMENT26 = 0x8CFA; +enum uint GL_COLOR_ATTACHMENT27 = 0x8CFB; +enum uint GL_COLOR_ATTACHMENT28 = 0x8CFC; +enum uint GL_COLOR_ATTACHMENT29 = 0x8CFD; +enum uint GL_COLOR_ATTACHMENT30 = 0x8CFE; +enum uint GL_COLOR_ATTACHMENT31 = 0x8CFF; +enum uint GL_DEPTH_ATTACHMENT = 0x8D00; +enum uint GL_STENCIL_ATTACHMENT = 0x8D20; +enum uint GL_FRAMEBUFFER = 0x8D40; +enum uint GL_RENDERBUFFER = 0x8D41; +enum uint GL_RENDERBUFFER_WIDTH = 0x8D42; +enum uint GL_RENDERBUFFER_HEIGHT = 0x8D43; +enum uint GL_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44; +enum uint GL_STENCIL_INDEX1 = 0x8D46; +enum uint GL_STENCIL_INDEX4 = 0x8D47; +enum uint GL_STENCIL_INDEX8 = 0x8D48; +enum uint GL_STENCIL_INDEX16 = 0x8D49; +enum uint GL_RENDERBUFFER_RED_SIZE = 0x8D50; +enum uint GL_RENDERBUFFER_GREEN_SIZE = 0x8D51; +enum uint GL_RENDERBUFFER_BLUE_SIZE = 0x8D52; +enum uint GL_RENDERBUFFER_ALPHA_SIZE = 0x8D53; +enum uint GL_RENDERBUFFER_DEPTH_SIZE = 0x8D54; +enum uint GL_RENDERBUFFER_STENCIL_SIZE = 0x8D55; +enum uint GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56; +enum uint GL_MAX_SAMPLES = 0x8D57; +enum uint GL_INDEX = 0x8222; +enum uint GL_TEXTURE_LUMINANCE_TYPE = 0x8C14; +enum uint GL_TEXTURE_INTENSITY_TYPE = 0x8C15; +enum uint GL_FRAMEBUFFER_SRGB = 0x8DB9; +enum uint GL_HALF_FLOAT = 0x140B; +enum uint GL_MAP_READ_BIT = 0x0001; +enum uint GL_MAP_WRITE_BIT = 0x0002; +enum uint GL_MAP_INVALIDATE_RANGE_BIT = 0x0004; +enum uint GL_MAP_INVALIDATE_BUFFER_BIT = 0x0008; +enum uint GL_MAP_FLUSH_EXPLICIT_BIT = 0x0010; +enum uint GL_MAP_UNSYNCHRONIZED_BIT = 0x0020; +enum uint GL_COMPRESSED_RED_RGTC1 = 0x8DBB; +enum uint GL_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC; +enum uint GL_COMPRESSED_RG_RGTC2 = 0x8DBD; +enum uint GL_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE; +enum uint GL_RG = 0x8227; +enum uint GL_RG_INTEGER = 0x8228; +enum uint GL_R8 = 0x8229; +enum uint GL_R16 = 0x822A; +enum uint GL_RG8 = 0x822B; +enum uint GL_RG16 = 0x822C; +enum uint GL_R16F = 0x822D; +enum uint GL_R32F = 0x822E; +enum uint GL_RG16F = 0x822F; +enum uint GL_RG32F = 0x8230; +enum uint GL_R8I = 0x8231; +enum uint GL_R8UI = 0x8232; +enum uint GL_R16I = 0x8233; +enum uint GL_R16UI = 0x8234; +enum uint GL_R32I = 0x8235; +enum uint GL_R32UI = 0x8236; +enum uint GL_RG8I = 0x8237; +enum uint GL_RG8UI = 0x8238; +enum uint GL_RG16I = 0x8239; +enum uint GL_RG16UI = 0x823A; +enum uint GL_RG32I = 0x823B; +enum uint GL_RG32UI = 0x823C; +enum uint GL_VERTEX_ARRAY_BINDING = 0x85B5; +enum uint GL_CLAMP_VERTEX_COLOR = 0x891A; +enum uint GL_CLAMP_FRAGMENT_COLOR = 0x891B; +enum uint GL_ALPHA_INTEGER = 0x8D97; +enum uint GL_SAMPLER_2D_RECT = 0x8B63; +enum uint GL_SAMPLER_2D_RECT_SHADOW = 0x8B64; +enum uint GL_SAMPLER_BUFFER = 0x8DC2; +enum uint GL_INT_SAMPLER_2D_RECT = 0x8DCD; +enum uint GL_INT_SAMPLER_BUFFER = 0x8DD0; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5; +enum uint GL_UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8; +enum uint GL_TEXTURE_BUFFER = 0x8C2A; +enum uint GL_MAX_TEXTURE_BUFFER_SIZE = 0x8C2B; +enum uint GL_TEXTURE_BINDING_BUFFER = 0x8C2C; +enum uint GL_TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D; +enum uint GL_TEXTURE_RECTANGLE = 0x84F5; +enum uint GL_TEXTURE_BINDING_RECTANGLE = 0x84F6; +enum uint GL_PROXY_TEXTURE_RECTANGLE = 0x84F7; +enum uint GL_MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8; +enum uint GL_R8_SNORM = 0x8F94; +enum uint GL_RG8_SNORM = 0x8F95; +enum uint GL_RGB8_SNORM = 0x8F96; +enum uint GL_RGBA8_SNORM = 0x8F97; +enum uint GL_R16_SNORM = 0x8F98; +enum uint GL_RG16_SNORM = 0x8F99; +enum uint GL_RGB16_SNORM = 0x8F9A; +enum uint GL_RGBA16_SNORM = 0x8F9B; +enum uint GL_SIGNED_NORMALIZED = 0x8F9C; +enum uint GL_PRIMITIVE_RESTART = 0x8F9D; +enum uint GL_PRIMITIVE_RESTART_INDEX = 0x8F9E; +enum uint GL_COPY_READ_BUFFER = 0x8F36; +enum uint GL_COPY_WRITE_BUFFER = 0x8F37; +enum uint GL_UNIFORM_BUFFER = 0x8A11; +enum uint GL_UNIFORM_BUFFER_BINDING = 0x8A28; +enum uint GL_UNIFORM_BUFFER_START = 0x8A29; +enum uint GL_UNIFORM_BUFFER_SIZE = 0x8A2A; +enum uint GL_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B; +enum uint GL_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C; +enum uint GL_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D; +enum uint GL_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E; +enum uint GL_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F; +enum uint GL_MAX_UNIFORM_BLOCK_SIZE = 0x8A30; +enum uint GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31; +enum uint GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32; +enum uint GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33; +enum uint GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34; +enum uint GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35; +enum uint GL_ACTIVE_UNIFORM_BLOCKS = 0x8A36; +enum uint GL_UNIFORM_TYPE = 0x8A37; +enum uint GL_UNIFORM_SIZE = 0x8A38; +enum uint GL_UNIFORM_NAME_LENGTH = 0x8A39; +enum uint GL_UNIFORM_BLOCK_INDEX = 0x8A3A; +enum uint GL_UNIFORM_OFFSET = 0x8A3B; +enum uint GL_UNIFORM_ARRAY_STRIDE = 0x8A3C; +enum uint GL_UNIFORM_MATRIX_STRIDE = 0x8A3D; +enum uint GL_UNIFORM_IS_ROW_MAJOR = 0x8A3E; +enum uint GL_UNIFORM_BLOCK_BINDING = 0x8A3F; +enum uint GL_UNIFORM_BLOCK_DATA_SIZE = 0x8A40; +enum uint GL_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41; +enum uint GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42; +enum uint GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43; +enum uint GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44; +enum uint GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45; +enum uint GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46; +enum uint GL_CONTEXT_CORE_PROFILE_BIT = 0x00000001; +enum uint GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002; +enum uint GL_LINES_ADJACENCY = 0x000A; +enum uint GL_LINE_STRIP_ADJACENCY = 0x000B; +enum uint GL_TRIANGLES_ADJACENCY = 0x000C; +enum uint GL_TRIANGLE_STRIP_ADJACENCY = 0x000D; +enum uint GL_PROGRAM_POINT_SIZE = 0x8642; +enum uint GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29; +enum uint GL_FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7; +enum uint GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8; +enum uint GL_GEOMETRY_SHADER = 0x8DD9; +enum uint GL_GEOMETRY_VERTICES_OUT = 0x8916; +enum uint GL_GEOMETRY_INPUT_TYPE = 0x8917; +enum uint GL_GEOMETRY_OUTPUT_TYPE = 0x8918; +enum uint GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF; +enum uint GL_MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0; +enum uint GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1; +enum uint GL_MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122; +enum uint GL_MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123; +enum uint GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124; +enum uint GL_MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125; +enum uint GL_CONTEXT_PROFILE_MASK = 0x9126; +enum uint GL_DEPTH_CLAMP = 0x864F; +enum uint GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C; +enum uint GL_FIRST_VERTEX_CONVENTION = 0x8E4D; +enum uint GL_LAST_VERTEX_CONVENTION = 0x8E4E; +enum uint GL_PROVOKING_VERTEX = 0x8E4F; +enum uint GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F; +enum uint GL_MAX_SERVER_WAIT_TIMEOUT = 0x9111; +enum uint GL_OBJECT_TYPE = 0x9112; +enum uint GL_SYNC_CONDITION = 0x9113; +enum uint GL_SYNC_STATUS = 0x9114; +enum uint GL_SYNC_FLAGS = 0x9115; +enum uint GL_SYNC_FENCE = 0x9116; +enum uint GL_SYNC_GPU_COMMANDS_COMPLETE = 0x9117; +enum uint GL_UNSIGNALED = 0x9118; +enum uint GL_SIGNALED = 0x9119; +enum uint GL_ALREADY_SIGNALED = 0x911A; +enum uint GL_TIMEOUT_EXPIRED = 0x911B; +enum uint GL_CONDITION_SATISFIED = 0x911C; +enum uint GL_WAIT_FAILED = 0x911D; +enum uint GL_SYNC_FLUSH_COMMANDS_BIT = 0x00000001; +enum uint GL_SAMPLE_POSITION = 0x8E50; +enum uint GL_SAMPLE_MASK = 0x8E51; +enum uint GL_SAMPLE_MASK_VALUE = 0x8E52; +enum uint GL_MAX_SAMPLE_MASK_WORDS = 0x8E59; +enum uint GL_TEXTURE_2D_MULTISAMPLE = 0x9100; +enum uint GL_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101; +enum uint GL_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102; +enum uint GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103; +enum uint GL_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104; +enum uint GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105; +enum uint GL_TEXTURE_SAMPLES = 0x9106; +enum uint GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107; +enum uint GL_SAMPLER_2D_MULTISAMPLE = 0x9108; +enum uint GL_INT_SAMPLER_2D_MULTISAMPLE = 0x9109; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A; +enum uint GL_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B; +enum uint GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C; +enum uint GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D; +enum uint GL_MAX_COLOR_TEXTURE_SAMPLES = 0x910E; +enum uint GL_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F; +enum uint GL_MAX_INTEGER_SAMPLES = 0x9110; +enum uint GL_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE; +enum uint GL_SRC1_COLOR = 0x88F9; +enum uint GL_ONE_MINUS_SRC1_COLOR = 0x88FA; +enum uint GL_ONE_MINUS_SRC1_ALPHA = 0x88FB; +enum uint GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC; +enum uint GL_ANY_SAMPLES_PASSED = 0x8C2F; +enum uint GL_SAMPLER_BINDING = 0x8919; +enum uint GL_RGB10_A2UI = 0x906F; +enum uint GL_TEXTURE_SWIZZLE_R = 0x8E42; +enum uint GL_TEXTURE_SWIZZLE_G = 0x8E43; +enum uint GL_TEXTURE_SWIZZLE_B = 0x8E44; +enum uint GL_TEXTURE_SWIZZLE_A = 0x8E45; +enum uint GL_TEXTURE_SWIZZLE_RGBA = 0x8E46; +enum uint GL_TIME_ELAPSED = 0x88BF; +enum uint GL_TIMESTAMP = 0x8E28; +enum uint GL_INT_2_10_10_10_REV = 0x8D9F; +enum uint GL_FIXED = 0x140C; +enum uint GL_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB; +enum uint GL_MAX_VARYING_VECTORS = 0x8DFC; +enum uint GL_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD; +enum uint GL_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A; +enum uint GL_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B; +enum uint GL_SHADER_COMPILER = 0x8DFA; +enum uint GL_SHADER_BINARY_FORMATS = 0x8DF8; +enum uint GL_NUM_SHADER_BINARY_FORMATS = 0x8DF9; +enum uint GL_LOW_FLOAT = 0x8DF0; +enum uint GL_MEDIUM_FLOAT = 0x8DF1; +enum uint GL_HIGH_FLOAT = 0x8DF2; +enum uint GL_LOW_INT = 0x8DF3; +enum uint GL_MEDIUM_INT = 0x8DF4; +enum uint GL_HIGH_INT = 0x8DF5; +enum uint GL_RGB565 = 0x8D62; +enum uint GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9; +enum uint GL_PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69; +enum uint GL_COPY_READ_BUFFER_BINDING = 0x8F36; +enum uint GL_COPY_WRITE_BUFFER_BINDING = 0x8F37; +enum uint GL_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A; +enum uint GL_TRANSFORM_FEEDBACK = 0x8E22; +enum uint GL_TRANSFORM_FEEDBACK_PAUSED = 0x8E23; +enum uint GL_TRANSFORM_FEEDBACK_ACTIVE = 0x8E24; +enum uint GL_TRANSFORM_FEEDBACK_BINDING = 0x8E25; +enum uint GL_PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257; +enum uint GL_PROGRAM_BINARY_LENGTH = 0x8741; +enum uint GL_NUM_PROGRAM_BINARY_FORMATS = 0x87FE; +enum uint GL_PROGRAM_BINARY_FORMATS = 0x87FF; +enum uint GL_COMPRESSED_R11_EAC = 0x9270; +enum uint GL_COMPRESSED_SIGNED_R11_EAC = 0x9271; +enum uint GL_COMPRESSED_RG11_EAC = 0x9272; +enum uint GL_COMPRESSED_SIGNED_RG11_EAC = 0x9273; +enum uint GL_COMPRESSED_RGB8_ETC2 = 0x9274; +enum uint GL_COMPRESSED_SRGB8_ETC2 = 0x9275; +enum uint GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276; +enum uint GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277; +enum uint GL_COMPRESSED_RGBA8_ETC2_EAC = 0x9278; +enum uint GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279; +enum uint GL_TEXTURE_IMMUTABLE_FORMAT = 0x912F; +enum uint GL_MAX_ELEMENT_INDEX = 0x8D6B; +enum uint GL_NUM_SAMPLE_COUNTS = 0x9380; +enum uint GL_TEXTURE_IMMUTABLE_LEVELS = 0x82DF; diff --git a/demos/external/sources/glad/gl/ext.d b/demos/external/sources/glad/gl/ext.d new file mode 100644 index 0000000..ad03be6 --- /dev/null +++ b/demos/external/sources/glad/gl/ext.d @@ -0,0 +1,10 @@ +module glad.gl.ext; + + +private import glad.gl.types; +private import glad.gl.enums; +private import glad.gl.funcs; +nothrow @nogc extern(System) { +} +__gshared { +} diff --git a/demos/external/sources/glad/gl/funcs.d b/demos/external/sources/glad/gl/funcs.d new file mode 100644 index 0000000..928cd83 --- /dev/null +++ b/demos/external/sources/glad/gl/funcs.d @@ -0,0 +1,1508 @@ +module glad.gl.funcs; + + +private import glad.gl.types; +bool GL_VERSION_1_0; +bool GL_VERSION_1_1; +bool GL_VERSION_1_2; +bool GL_VERSION_1_3; +bool GL_VERSION_1_4; +bool GL_VERSION_1_5; +bool GL_VERSION_2_0; +bool GL_VERSION_2_1; +bool GL_VERSION_3_0; +bool GL_VERSION_3_1; +bool GL_VERSION_3_2; +bool GL_VERSION_3_3; +bool GL_ES_VERSION_2_0; +bool GL_ES_VERSION_3_0; +nothrow @nogc extern(System) { +alias fp_glCullFace = void function(GLenum); +alias fp_glFrontFace = void function(GLenum); +alias fp_glHint = void function(GLenum, GLenum); +alias fp_glLineWidth = void function(GLfloat); +alias fp_glPointSize = void function(GLfloat); +alias fp_glPolygonMode = void function(GLenum, GLenum); +alias fp_glScissor = void function(GLint, GLint, GLsizei, GLsizei); +alias fp_glTexParameterf = void function(GLenum, GLenum, GLfloat); +alias fp_glTexParameterfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glTexParameteri = void function(GLenum, GLenum, GLint); +alias fp_glTexParameteriv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glTexImage1D = void function(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const(void)*); +alias fp_glTexImage2D = void function(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const(void)*); +alias fp_glDrawBuffer = void function(GLenum); +alias fp_glClear = void function(GLbitfield); +alias fp_glClearColor = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glClearStencil = void function(GLint); +alias fp_glClearDepth = void function(GLdouble); +alias fp_glStencilMask = void function(GLuint); +alias fp_glColorMask = void function(GLboolean, GLboolean, GLboolean, GLboolean); +alias fp_glDepthMask = void function(GLboolean); +alias fp_glDisable = void function(GLenum); +alias fp_glEnable = void function(GLenum); +alias fp_glFinish = void function(); +alias fp_glFlush = void function(); +alias fp_glBlendFunc = void function(GLenum, GLenum); +alias fp_glLogicOp = void function(GLenum); +alias fp_glStencilFunc = void function(GLenum, GLint, GLuint); +alias fp_glStencilOp = void function(GLenum, GLenum, GLenum); +alias fp_glDepthFunc = void function(GLenum); +alias fp_glPixelStoref = void function(GLenum, GLfloat); +alias fp_glPixelStorei = void function(GLenum, GLint); +alias fp_glReadBuffer = void function(GLenum); +alias fp_glReadPixels = void function(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, void*); +alias fp_glGetBooleanv = void function(GLenum, GLboolean*); +alias fp_glGetDoublev = void function(GLenum, GLdouble*); +alias fp_glGetError = GLenum function(); +alias fp_glGetFloatv = void function(GLenum, GLfloat*); +alias fp_glGetIntegerv = void function(GLenum, GLint*); +alias fp_glGetString = const(GLubyte)* function(GLenum); +alias fp_glGetTexImage = void function(GLenum, GLint, GLenum, GLenum, void*); +alias fp_glGetTexParameterfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetTexParameteriv = void function(GLenum, GLenum, GLint*); +alias fp_glGetTexLevelParameterfv = void function(GLenum, GLint, GLenum, GLfloat*); +alias fp_glGetTexLevelParameteriv = void function(GLenum, GLint, GLenum, GLint*); +alias fp_glIsEnabled = GLboolean function(GLenum); +alias fp_glDepthRange = void function(GLdouble, GLdouble); +alias fp_glViewport = void function(GLint, GLint, GLsizei, GLsizei); +alias fp_glNewList = void function(GLuint, GLenum); +alias fp_glEndList = void function(); +alias fp_glCallList = void function(GLuint); +alias fp_glCallLists = void function(GLsizei, GLenum, const(void)*); +alias fp_glDeleteLists = void function(GLuint, GLsizei); +alias fp_glGenLists = GLuint function(GLsizei); +alias fp_glListBase = void function(GLuint); +alias fp_glBegin = void function(GLenum); +alias fp_glBitmap = void function(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const(GLubyte)*); +alias fp_glColor3b = void function(GLbyte, GLbyte, GLbyte); +alias fp_glColor3bv = void function(const(GLbyte)*); +alias fp_glColor3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glColor3dv = void function(const(GLdouble)*); +alias fp_glColor3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glColor3fv = void function(const(GLfloat)*); +alias fp_glColor3i = void function(GLint, GLint, GLint); +alias fp_glColor3iv = void function(const(GLint)*); +alias fp_glColor3s = void function(GLshort, GLshort, GLshort); +alias fp_glColor3sv = void function(const(GLshort)*); +alias fp_glColor3ub = void function(GLubyte, GLubyte, GLubyte); +alias fp_glColor3ubv = void function(const(GLubyte)*); +alias fp_glColor3ui = void function(GLuint, GLuint, GLuint); +alias fp_glColor3uiv = void function(const(GLuint)*); +alias fp_glColor3us = void function(GLushort, GLushort, GLushort); +alias fp_glColor3usv = void function(const(GLushort)*); +alias fp_glColor4b = void function(GLbyte, GLbyte, GLbyte, GLbyte); +alias fp_glColor4bv = void function(const(GLbyte)*); +alias fp_glColor4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glColor4dv = void function(const(GLdouble)*); +alias fp_glColor4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glColor4fv = void function(const(GLfloat)*); +alias fp_glColor4i = void function(GLint, GLint, GLint, GLint); +alias fp_glColor4iv = void function(const(GLint)*); +alias fp_glColor4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glColor4sv = void function(const(GLshort)*); +alias fp_glColor4ub = void function(GLubyte, GLubyte, GLubyte, GLubyte); +alias fp_glColor4ubv = void function(const(GLubyte)*); +alias fp_glColor4ui = void function(GLuint, GLuint, GLuint, GLuint); +alias fp_glColor4uiv = void function(const(GLuint)*); +alias fp_glColor4us = void function(GLushort, GLushort, GLushort, GLushort); +alias fp_glColor4usv = void function(const(GLushort)*); +alias fp_glEdgeFlag = void function(GLboolean); +alias fp_glEdgeFlagv = void function(const(GLboolean)*); +alias fp_glEnd = void function(); +alias fp_glIndexd = void function(GLdouble); +alias fp_glIndexdv = void function(const(GLdouble)*); +alias fp_glIndexf = void function(GLfloat); +alias fp_glIndexfv = void function(const(GLfloat)*); +alias fp_glIndexi = void function(GLint); +alias fp_glIndexiv = void function(const(GLint)*); +alias fp_glIndexs = void function(GLshort); +alias fp_glIndexsv = void function(const(GLshort)*); +alias fp_glNormal3b = void function(GLbyte, GLbyte, GLbyte); +alias fp_glNormal3bv = void function(const(GLbyte)*); +alias fp_glNormal3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glNormal3dv = void function(const(GLdouble)*); +alias fp_glNormal3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glNormal3fv = void function(const(GLfloat)*); +alias fp_glNormal3i = void function(GLint, GLint, GLint); +alias fp_glNormal3iv = void function(const(GLint)*); +alias fp_glNormal3s = void function(GLshort, GLshort, GLshort); +alias fp_glNormal3sv = void function(const(GLshort)*); +alias fp_glRasterPos2d = void function(GLdouble, GLdouble); +alias fp_glRasterPos2dv = void function(const(GLdouble)*); +alias fp_glRasterPos2f = void function(GLfloat, GLfloat); +alias fp_glRasterPos2fv = void function(const(GLfloat)*); +alias fp_glRasterPos2i = void function(GLint, GLint); +alias fp_glRasterPos2iv = void function(const(GLint)*); +alias fp_glRasterPos2s = void function(GLshort, GLshort); +alias fp_glRasterPos2sv = void function(const(GLshort)*); +alias fp_glRasterPos3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glRasterPos3dv = void function(const(GLdouble)*); +alias fp_glRasterPos3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glRasterPos3fv = void function(const(GLfloat)*); +alias fp_glRasterPos3i = void function(GLint, GLint, GLint); +alias fp_glRasterPos3iv = void function(const(GLint)*); +alias fp_glRasterPos3s = void function(GLshort, GLshort, GLshort); +alias fp_glRasterPos3sv = void function(const(GLshort)*); +alias fp_glRasterPos4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glRasterPos4dv = void function(const(GLdouble)*); +alias fp_glRasterPos4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glRasterPos4fv = void function(const(GLfloat)*); +alias fp_glRasterPos4i = void function(GLint, GLint, GLint, GLint); +alias fp_glRasterPos4iv = void function(const(GLint)*); +alias fp_glRasterPos4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glRasterPos4sv = void function(const(GLshort)*); +alias fp_glRectd = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glRectdv = void function(const(GLdouble)*, const(GLdouble)*); +alias fp_glRectf = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glRectfv = void function(const(GLfloat)*, const(GLfloat)*); +alias fp_glRecti = void function(GLint, GLint, GLint, GLint); +alias fp_glRectiv = void function(const(GLint)*, const(GLint)*); +alias fp_glRects = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glRectsv = void function(const(GLshort)*, const(GLshort)*); +alias fp_glTexCoord1d = void function(GLdouble); +alias fp_glTexCoord1dv = void function(const(GLdouble)*); +alias fp_glTexCoord1f = void function(GLfloat); +alias fp_glTexCoord1fv = void function(const(GLfloat)*); +alias fp_glTexCoord1i = void function(GLint); +alias fp_glTexCoord1iv = void function(const(GLint)*); +alias fp_glTexCoord1s = void function(GLshort); +alias fp_glTexCoord1sv = void function(const(GLshort)*); +alias fp_glTexCoord2d = void function(GLdouble, GLdouble); +alias fp_glTexCoord2dv = void function(const(GLdouble)*); +alias fp_glTexCoord2f = void function(GLfloat, GLfloat); +alias fp_glTexCoord2fv = void function(const(GLfloat)*); +alias fp_glTexCoord2i = void function(GLint, GLint); +alias fp_glTexCoord2iv = void function(const(GLint)*); +alias fp_glTexCoord2s = void function(GLshort, GLshort); +alias fp_glTexCoord2sv = void function(const(GLshort)*); +alias fp_glTexCoord3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glTexCoord3dv = void function(const(GLdouble)*); +alias fp_glTexCoord3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glTexCoord3fv = void function(const(GLfloat)*); +alias fp_glTexCoord3i = void function(GLint, GLint, GLint); +alias fp_glTexCoord3iv = void function(const(GLint)*); +alias fp_glTexCoord3s = void function(GLshort, GLshort, GLshort); +alias fp_glTexCoord3sv = void function(const(GLshort)*); +alias fp_glTexCoord4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glTexCoord4dv = void function(const(GLdouble)*); +alias fp_glTexCoord4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glTexCoord4fv = void function(const(GLfloat)*); +alias fp_glTexCoord4i = void function(GLint, GLint, GLint, GLint); +alias fp_glTexCoord4iv = void function(const(GLint)*); +alias fp_glTexCoord4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glTexCoord4sv = void function(const(GLshort)*); +alias fp_glVertex2d = void function(GLdouble, GLdouble); +alias fp_glVertex2dv = void function(const(GLdouble)*); +alias fp_glVertex2f = void function(GLfloat, GLfloat); +alias fp_glVertex2fv = void function(const(GLfloat)*); +alias fp_glVertex2i = void function(GLint, GLint); +alias fp_glVertex2iv = void function(const(GLint)*); +alias fp_glVertex2s = void function(GLshort, GLshort); +alias fp_glVertex2sv = void function(const(GLshort)*); +alias fp_glVertex3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glVertex3dv = void function(const(GLdouble)*); +alias fp_glVertex3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glVertex3fv = void function(const(GLfloat)*); +alias fp_glVertex3i = void function(GLint, GLint, GLint); +alias fp_glVertex3iv = void function(const(GLint)*); +alias fp_glVertex3s = void function(GLshort, GLshort, GLshort); +alias fp_glVertex3sv = void function(const(GLshort)*); +alias fp_glVertex4d = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glVertex4dv = void function(const(GLdouble)*); +alias fp_glVertex4f = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glVertex4fv = void function(const(GLfloat)*); +alias fp_glVertex4i = void function(GLint, GLint, GLint, GLint); +alias fp_glVertex4iv = void function(const(GLint)*); +alias fp_glVertex4s = void function(GLshort, GLshort, GLshort, GLshort); +alias fp_glVertex4sv = void function(const(GLshort)*); +alias fp_glClipPlane = void function(GLenum, const(GLdouble)*); +alias fp_glColorMaterial = void function(GLenum, GLenum); +alias fp_glFogf = void function(GLenum, GLfloat); +alias fp_glFogfv = void function(GLenum, const(GLfloat)*); +alias fp_glFogi = void function(GLenum, GLint); +alias fp_glFogiv = void function(GLenum, const(GLint)*); +alias fp_glLightf = void function(GLenum, GLenum, GLfloat); +alias fp_glLightfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glLighti = void function(GLenum, GLenum, GLint); +alias fp_glLightiv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glLightModelf = void function(GLenum, GLfloat); +alias fp_glLightModelfv = void function(GLenum, const(GLfloat)*); +alias fp_glLightModeli = void function(GLenum, GLint); +alias fp_glLightModeliv = void function(GLenum, const(GLint)*); +alias fp_glLineStipple = void function(GLint, GLushort); +alias fp_glMaterialf = void function(GLenum, GLenum, GLfloat); +alias fp_glMaterialfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glMateriali = void function(GLenum, GLenum, GLint); +alias fp_glMaterialiv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glPolygonStipple = void function(const(GLubyte)*); +alias fp_glShadeModel = void function(GLenum); +alias fp_glTexEnvf = void function(GLenum, GLenum, GLfloat); +alias fp_glTexEnvfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glTexEnvi = void function(GLenum, GLenum, GLint); +alias fp_glTexEnviv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glTexGend = void function(GLenum, GLenum, GLdouble); +alias fp_glTexGendv = void function(GLenum, GLenum, const(GLdouble)*); +alias fp_glTexGenf = void function(GLenum, GLenum, GLfloat); +alias fp_glTexGenfv = void function(GLenum, GLenum, const(GLfloat)*); +alias fp_glTexGeni = void function(GLenum, GLenum, GLint); +alias fp_glTexGeniv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glFeedbackBuffer = void function(GLsizei, GLenum, GLfloat*); +alias fp_glSelectBuffer = void function(GLsizei, GLuint*); +alias fp_glRenderMode = GLint function(GLenum); +alias fp_glInitNames = void function(); +alias fp_glLoadName = void function(GLuint); +alias fp_glPassThrough = void function(GLfloat); +alias fp_glPopName = void function(); +alias fp_glPushName = void function(GLuint); +alias fp_glClearAccum = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glClearIndex = void function(GLfloat); +alias fp_glIndexMask = void function(GLuint); +alias fp_glAccum = void function(GLenum, GLfloat); +alias fp_glPopAttrib = void function(); +alias fp_glPushAttrib = void function(GLbitfield); +alias fp_glMap1d = void function(GLenum, GLdouble, GLdouble, GLint, GLint, const(GLdouble)*); +alias fp_glMap1f = void function(GLenum, GLfloat, GLfloat, GLint, GLint, const(GLfloat)*); +alias fp_glMap2d = void function(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const(GLdouble)*); +alias fp_glMap2f = void function(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const(GLfloat)*); +alias fp_glMapGrid1d = void function(GLint, GLdouble, GLdouble); +alias fp_glMapGrid1f = void function(GLint, GLfloat, GLfloat); +alias fp_glMapGrid2d = void function(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble); +alias fp_glMapGrid2f = void function(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat); +alias fp_glEvalCoord1d = void function(GLdouble); +alias fp_glEvalCoord1dv = void function(const(GLdouble)*); +alias fp_glEvalCoord1f = void function(GLfloat); +alias fp_glEvalCoord1fv = void function(const(GLfloat)*); +alias fp_glEvalCoord2d = void function(GLdouble, GLdouble); +alias fp_glEvalCoord2dv = void function(const(GLdouble)*); +alias fp_glEvalCoord2f = void function(GLfloat, GLfloat); +alias fp_glEvalCoord2fv = void function(const(GLfloat)*); +alias fp_glEvalMesh1 = void function(GLenum, GLint, GLint); +alias fp_glEvalPoint1 = void function(GLint); +alias fp_glEvalMesh2 = void function(GLenum, GLint, GLint, GLint, GLint); +alias fp_glEvalPoint2 = void function(GLint, GLint); +alias fp_glAlphaFunc = void function(GLenum, GLfloat); +alias fp_glPixelZoom = void function(GLfloat, GLfloat); +alias fp_glPixelTransferf = void function(GLenum, GLfloat); +alias fp_glPixelTransferi = void function(GLenum, GLint); +alias fp_glPixelMapfv = void function(GLenum, GLsizei, const(GLfloat)*); +alias fp_glPixelMapuiv = void function(GLenum, GLsizei, const(GLuint)*); +alias fp_glPixelMapusv = void function(GLenum, GLsizei, const(GLushort)*); +alias fp_glCopyPixels = void function(GLint, GLint, GLsizei, GLsizei, GLenum); +alias fp_glDrawPixels = void function(GLsizei, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glGetClipPlane = void function(GLenum, GLdouble*); +alias fp_glGetLightfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetLightiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetMapdv = void function(GLenum, GLenum, GLdouble*); +alias fp_glGetMapfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetMapiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetMaterialfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetMaterialiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetPixelMapfv = void function(GLenum, GLfloat*); +alias fp_glGetPixelMapuiv = void function(GLenum, GLuint*); +alias fp_glGetPixelMapusv = void function(GLenum, GLushort*); +alias fp_glGetPolygonStipple = void function(GLubyte*); +alias fp_glGetTexEnvfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetTexEnviv = void function(GLenum, GLenum, GLint*); +alias fp_glGetTexGendv = void function(GLenum, GLenum, GLdouble*); +alias fp_glGetTexGenfv = void function(GLenum, GLenum, GLfloat*); +alias fp_glGetTexGeniv = void function(GLenum, GLenum, GLint*); +alias fp_glIsList = GLboolean function(GLuint); +alias fp_glFrustum = void function(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glLoadIdentity = void function(); +alias fp_glLoadMatrixf = void function(const(GLfloat)*); +alias fp_glLoadMatrixd = void function(const(GLdouble)*); +alias fp_glMatrixMode = void function(GLenum); +alias fp_glMultMatrixf = void function(const(GLfloat)*); +alias fp_glMultMatrixd = void function(const(GLdouble)*); +alias fp_glOrtho = void function(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glPopMatrix = void function(); +alias fp_glPushMatrix = void function(); +alias fp_glRotated = void function(GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glRotatef = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glScaled = void function(GLdouble, GLdouble, GLdouble); +alias fp_glScalef = void function(GLfloat, GLfloat, GLfloat); +alias fp_glTranslated = void function(GLdouble, GLdouble, GLdouble); +alias fp_glTranslatef = void function(GLfloat, GLfloat, GLfloat); +alias fp_glDrawArrays = void function(GLenum, GLint, GLsizei); +alias fp_glDrawElements = void function(GLenum, GLsizei, GLenum, const(void)*); +alias fp_glGetPointerv = void function(GLenum, void**); +alias fp_glPolygonOffset = void function(GLfloat, GLfloat); +alias fp_glCopyTexImage1D = void function(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint); +alias fp_glCopyTexImage2D = void function(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); +alias fp_glCopyTexSubImage1D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei); +alias fp_glCopyTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +alias fp_glTexSubImage1D = void function(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glBindTexture = void function(GLenum, GLuint); +alias fp_glDeleteTextures = void function(GLsizei, const(GLuint)*); +alias fp_glGenTextures = void function(GLsizei, GLuint*); +alias fp_glIsTexture = GLboolean function(GLuint); +alias fp_glArrayElement = void function(GLint); +alias fp_glColorPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glDisableClientState = void function(GLenum); +alias fp_glEdgeFlagPointer = void function(GLsizei, const(void)*); +alias fp_glEnableClientState = void function(GLenum); +alias fp_glIndexPointer = void function(GLenum, GLsizei, const(void)*); +alias fp_glInterleavedArrays = void function(GLenum, GLsizei, const(void)*); +alias fp_glNormalPointer = void function(GLenum, GLsizei, const(void)*); +alias fp_glTexCoordPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glVertexPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glAreTexturesResident = GLboolean function(GLsizei, const(GLuint)*, GLboolean*); +alias fp_glPrioritizeTextures = void function(GLsizei, const(GLuint)*, const(GLfloat)*); +alias fp_glIndexub = void function(GLubyte); +alias fp_glIndexubv = void function(const(GLubyte)*); +alias fp_glPopClientAttrib = void function(); +alias fp_glPushClientAttrib = void function(GLbitfield); +alias fp_glDrawRangeElements = void function(GLenum, GLuint, GLuint, GLsizei, GLenum, const(void)*); +alias fp_glTexImage3D = void function(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const(void)*); +alias fp_glTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const(void)*); +alias fp_glCopyTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +alias fp_glActiveTexture = void function(GLenum); +alias fp_glSampleCoverage = void function(GLfloat, GLboolean); +alias fp_glCompressedTexImage3D = void function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const(void)*); +alias fp_glCompressedTexImage2D = void function(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const(void)*); +alias fp_glCompressedTexImage1D = void function(GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const(void)*); +alias fp_glCompressedTexSubImage3D = void function(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const(void)*); +alias fp_glCompressedTexSubImage2D = void function(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const(void)*); +alias fp_glCompressedTexSubImage1D = void function(GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const(void)*); +alias fp_glGetCompressedTexImage = void function(GLenum, GLint, void*); +alias fp_glClientActiveTexture = void function(GLenum); +alias fp_glMultiTexCoord1d = void function(GLenum, GLdouble); +alias fp_glMultiTexCoord1dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord1f = void function(GLenum, GLfloat); +alias fp_glMultiTexCoord1fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord1i = void function(GLenum, GLint); +alias fp_glMultiTexCoord1iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord1s = void function(GLenum, GLshort); +alias fp_glMultiTexCoord1sv = void function(GLenum, const(GLshort)*); +alias fp_glMultiTexCoord2d = void function(GLenum, GLdouble, GLdouble); +alias fp_glMultiTexCoord2dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord2f = void function(GLenum, GLfloat, GLfloat); +alias fp_glMultiTexCoord2fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord2i = void function(GLenum, GLint, GLint); +alias fp_glMultiTexCoord2iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord2s = void function(GLenum, GLshort, GLshort); +alias fp_glMultiTexCoord2sv = void function(GLenum, const(GLshort)*); +alias fp_glMultiTexCoord3d = void function(GLenum, GLdouble, GLdouble, GLdouble); +alias fp_glMultiTexCoord3dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord3f = void function(GLenum, GLfloat, GLfloat, GLfloat); +alias fp_glMultiTexCoord3fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord3i = void function(GLenum, GLint, GLint, GLint); +alias fp_glMultiTexCoord3iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord3s = void function(GLenum, GLshort, GLshort, GLshort); +alias fp_glMultiTexCoord3sv = void function(GLenum, const(GLshort)*); +alias fp_glMultiTexCoord4d = void function(GLenum, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glMultiTexCoord4dv = void function(GLenum, const(GLdouble)*); +alias fp_glMultiTexCoord4f = void function(GLenum, GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glMultiTexCoord4fv = void function(GLenum, const(GLfloat)*); +alias fp_glMultiTexCoord4i = void function(GLenum, GLint, GLint, GLint, GLint); +alias fp_glMultiTexCoord4iv = void function(GLenum, const(GLint)*); +alias fp_glMultiTexCoord4s = void function(GLenum, GLshort, GLshort, GLshort, GLshort); +alias fp_glMultiTexCoord4sv = void function(GLenum, const(GLshort)*); +alias fp_glLoadTransposeMatrixf = void function(const(GLfloat)*); +alias fp_glLoadTransposeMatrixd = void function(const(GLdouble)*); +alias fp_glMultTransposeMatrixf = void function(const(GLfloat)*); +alias fp_glMultTransposeMatrixd = void function(const(GLdouble)*); +alias fp_glBlendFuncSeparate = void function(GLenum, GLenum, GLenum, GLenum); +alias fp_glMultiDrawArrays = void function(GLenum, const(GLint)*, const(GLsizei)*, GLsizei); +alias fp_glMultiDrawElements = void function(GLenum, const(GLsizei)*, GLenum, const(void*)*, GLsizei); +alias fp_glPointParameterf = void function(GLenum, GLfloat); +alias fp_glPointParameterfv = void function(GLenum, const(GLfloat)*); +alias fp_glPointParameteri = void function(GLenum, GLint); +alias fp_glPointParameteriv = void function(GLenum, const(GLint)*); +alias fp_glFogCoordf = void function(GLfloat); +alias fp_glFogCoordfv = void function(const(GLfloat)*); +alias fp_glFogCoordd = void function(GLdouble); +alias fp_glFogCoorddv = void function(const(GLdouble)*); +alias fp_glFogCoordPointer = void function(GLenum, GLsizei, const(void)*); +alias fp_glSecondaryColor3b = void function(GLbyte, GLbyte, GLbyte); +alias fp_glSecondaryColor3bv = void function(const(GLbyte)*); +alias fp_glSecondaryColor3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glSecondaryColor3dv = void function(const(GLdouble)*); +alias fp_glSecondaryColor3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glSecondaryColor3fv = void function(const(GLfloat)*); +alias fp_glSecondaryColor3i = void function(GLint, GLint, GLint); +alias fp_glSecondaryColor3iv = void function(const(GLint)*); +alias fp_glSecondaryColor3s = void function(GLshort, GLshort, GLshort); +alias fp_glSecondaryColor3sv = void function(const(GLshort)*); +alias fp_glSecondaryColor3ub = void function(GLubyte, GLubyte, GLubyte); +alias fp_glSecondaryColor3ubv = void function(const(GLubyte)*); +alias fp_glSecondaryColor3ui = void function(GLuint, GLuint, GLuint); +alias fp_glSecondaryColor3uiv = void function(const(GLuint)*); +alias fp_glSecondaryColor3us = void function(GLushort, GLushort, GLushort); +alias fp_glSecondaryColor3usv = void function(const(GLushort)*); +alias fp_glSecondaryColorPointer = void function(GLint, GLenum, GLsizei, const(void)*); +alias fp_glWindowPos2d = void function(GLdouble, GLdouble); +alias fp_glWindowPos2dv = void function(const(GLdouble)*); +alias fp_glWindowPos2f = void function(GLfloat, GLfloat); +alias fp_glWindowPos2fv = void function(const(GLfloat)*); +alias fp_glWindowPos2i = void function(GLint, GLint); +alias fp_glWindowPos2iv = void function(const(GLint)*); +alias fp_glWindowPos2s = void function(GLshort, GLshort); +alias fp_glWindowPos2sv = void function(const(GLshort)*); +alias fp_glWindowPos3d = void function(GLdouble, GLdouble, GLdouble); +alias fp_glWindowPos3dv = void function(const(GLdouble)*); +alias fp_glWindowPos3f = void function(GLfloat, GLfloat, GLfloat); +alias fp_glWindowPos3fv = void function(const(GLfloat)*); +alias fp_glWindowPos3i = void function(GLint, GLint, GLint); +alias fp_glWindowPos3iv = void function(const(GLint)*); +alias fp_glWindowPos3s = void function(GLshort, GLshort, GLshort); +alias fp_glWindowPos3sv = void function(const(GLshort)*); +alias fp_glBlendColor = void function(GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glBlendEquation = void function(GLenum); +alias fp_glGenQueries = void function(GLsizei, GLuint*); +alias fp_glDeleteQueries = void function(GLsizei, const(GLuint)*); +alias fp_glIsQuery = GLboolean function(GLuint); +alias fp_glBeginQuery = void function(GLenum, GLuint); +alias fp_glEndQuery = void function(GLenum); +alias fp_glGetQueryiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetQueryObjectiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetQueryObjectuiv = void function(GLuint, GLenum, GLuint*); +alias fp_glBindBuffer = void function(GLenum, GLuint); +alias fp_glDeleteBuffers = void function(GLsizei, const(GLuint)*); +alias fp_glGenBuffers = void function(GLsizei, GLuint*); +alias fp_glIsBuffer = GLboolean function(GLuint); +alias fp_glBufferData = void function(GLenum, GLsizeiptr, const(void)*, GLenum); +alias fp_glBufferSubData = void function(GLenum, GLintptr, GLsizeiptr, const(void)*); +alias fp_glGetBufferSubData = void function(GLenum, GLintptr, GLsizeiptr, void*); +alias fp_glMapBuffer = void* function(GLenum, GLenum); +alias fp_glUnmapBuffer = GLboolean function(GLenum); +alias fp_glGetBufferParameteriv = void function(GLenum, GLenum, GLint*); +alias fp_glGetBufferPointerv = void function(GLenum, GLenum, void**); +alias fp_glBlendEquationSeparate = void function(GLenum, GLenum); +alias fp_glDrawBuffers = void function(GLsizei, const(GLenum)*); +alias fp_glStencilOpSeparate = void function(GLenum, GLenum, GLenum, GLenum); +alias fp_glStencilFuncSeparate = void function(GLenum, GLenum, GLint, GLuint); +alias fp_glStencilMaskSeparate = void function(GLenum, GLuint); +alias fp_glAttachShader = void function(GLuint, GLuint); +alias fp_glBindAttribLocation = void function(GLuint, GLuint, const(GLchar)*); +alias fp_glCompileShader = void function(GLuint); +alias fp_glCreateProgram = GLuint function(); +alias fp_glCreateShader = GLuint function(GLenum); +alias fp_glDeleteProgram = void function(GLuint); +alias fp_glDeleteShader = void function(GLuint); +alias fp_glDetachShader = void function(GLuint, GLuint); +alias fp_glDisableVertexAttribArray = void function(GLuint); +alias fp_glEnableVertexAttribArray = void function(GLuint); +alias fp_glGetActiveAttrib = void function(GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*); +alias fp_glGetActiveUniform = void function(GLuint, GLuint, GLsizei, GLsizei*, GLint*, GLenum*, GLchar*); +alias fp_glGetAttachedShaders = void function(GLuint, GLsizei, GLsizei*, GLuint*); +alias fp_glGetAttribLocation = GLint function(GLuint, const(GLchar)*); +alias fp_glGetProgramiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetProgramInfoLog = void function(GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetShaderiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetShaderInfoLog = void function(GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetShaderSource = void function(GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetUniformLocation = GLint function(GLuint, const(GLchar)*); +alias fp_glGetUniformfv = void function(GLuint, GLint, GLfloat*); +alias fp_glGetUniformiv = void function(GLuint, GLint, GLint*); +alias fp_glGetVertexAttribdv = void function(GLuint, GLenum, GLdouble*); +alias fp_glGetVertexAttribfv = void function(GLuint, GLenum, GLfloat*); +alias fp_glGetVertexAttribiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetVertexAttribPointerv = void function(GLuint, GLenum, void**); +alias fp_glIsProgram = GLboolean function(GLuint); +alias fp_glIsShader = GLboolean function(GLuint); +alias fp_glLinkProgram = void function(GLuint); +alias fp_glShaderSource = void function(GLuint, GLsizei, const(GLchar*)*, const(GLint)*); +alias fp_glUseProgram = void function(GLuint); +alias fp_glUniform1f = void function(GLint, GLfloat); +alias fp_glUniform2f = void function(GLint, GLfloat, GLfloat); +alias fp_glUniform3f = void function(GLint, GLfloat, GLfloat, GLfloat); +alias fp_glUniform4f = void function(GLint, GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glUniform1i = void function(GLint, GLint); +alias fp_glUniform2i = void function(GLint, GLint, GLint); +alias fp_glUniform3i = void function(GLint, GLint, GLint, GLint); +alias fp_glUniform4i = void function(GLint, GLint, GLint, GLint, GLint); +alias fp_glUniform1fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform2fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform3fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform4fv = void function(GLint, GLsizei, const(GLfloat)*); +alias fp_glUniform1iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniform2iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniform3iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniform4iv = void function(GLint, GLsizei, const(GLint)*); +alias fp_glUniformMatrix2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glValidateProgram = void function(GLuint); +alias fp_glVertexAttrib1d = void function(GLuint, GLdouble); +alias fp_glVertexAttrib1dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib1f = void function(GLuint, GLfloat); +alias fp_glVertexAttrib1fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib1s = void function(GLuint, GLshort); +alias fp_glVertexAttrib1sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib2d = void function(GLuint, GLdouble, GLdouble); +alias fp_glVertexAttrib2dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib2f = void function(GLuint, GLfloat, GLfloat); +alias fp_glVertexAttrib2fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib2s = void function(GLuint, GLshort, GLshort); +alias fp_glVertexAttrib2sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib3d = void function(GLuint, GLdouble, GLdouble, GLdouble); +alias fp_glVertexAttrib3dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib3f = void function(GLuint, GLfloat, GLfloat, GLfloat); +alias fp_glVertexAttrib3fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib3s = void function(GLuint, GLshort, GLshort, GLshort); +alias fp_glVertexAttrib3sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib4Nbv = void function(GLuint, const(GLbyte)*); +alias fp_glVertexAttrib4Niv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttrib4Nsv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib4Nub = void function(GLuint, GLubyte, GLubyte, GLubyte, GLubyte); +alias fp_glVertexAttrib4Nubv = void function(GLuint, const(GLubyte)*); +alias fp_glVertexAttrib4Nuiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttrib4Nusv = void function(GLuint, const(GLushort)*); +alias fp_glVertexAttrib4bv = void function(GLuint, const(GLbyte)*); +alias fp_glVertexAttrib4d = void function(GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +alias fp_glVertexAttrib4dv = void function(GLuint, const(GLdouble)*); +alias fp_glVertexAttrib4f = void function(GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +alias fp_glVertexAttrib4fv = void function(GLuint, const(GLfloat)*); +alias fp_glVertexAttrib4iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttrib4s = void function(GLuint, GLshort, GLshort, GLshort, GLshort); +alias fp_glVertexAttrib4sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttrib4ubv = void function(GLuint, const(GLubyte)*); +alias fp_glVertexAttrib4uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttrib4usv = void function(GLuint, const(GLushort)*); +alias fp_glVertexAttribPointer = void function(GLuint, GLint, GLenum, GLboolean, GLsizei, const(void)*); +alias fp_glUniformMatrix2x3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix3x2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix2x4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix4x2fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix3x4fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glUniformMatrix4x3fv = void function(GLint, GLsizei, GLboolean, const(GLfloat)*); +alias fp_glColorMaski = void function(GLuint, GLboolean, GLboolean, GLboolean, GLboolean); +alias fp_glGetBooleani_v = void function(GLenum, GLuint, GLboolean*); +alias fp_glGetIntegeri_v = void function(GLenum, GLuint, GLint*); +alias fp_glEnablei = void function(GLenum, GLuint); +alias fp_glDisablei = void function(GLenum, GLuint); +alias fp_glIsEnabledi = GLboolean function(GLenum, GLuint); +alias fp_glBeginTransformFeedback = void function(GLenum); +alias fp_glEndTransformFeedback = void function(); +alias fp_glBindBufferRange = void function(GLenum, GLuint, GLuint, GLintptr, GLsizeiptr); +alias fp_glBindBufferBase = void function(GLenum, GLuint, GLuint); +alias fp_glTransformFeedbackVaryings = void function(GLuint, GLsizei, const(GLchar*)*, GLenum); +alias fp_glGetTransformFeedbackVarying = void function(GLuint, GLuint, GLsizei, GLsizei*, GLsizei*, GLenum*, GLchar*); +alias fp_glClampColor = void function(GLenum, GLenum); +alias fp_glBeginConditionalRender = void function(GLuint, GLenum); +alias fp_glEndConditionalRender = void function(); +alias fp_glVertexAttribIPointer = void function(GLuint, GLint, GLenum, GLsizei, const(void)*); +alias fp_glGetVertexAttribIiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetVertexAttribIuiv = void function(GLuint, GLenum, GLuint*); +alias fp_glVertexAttribI1i = void function(GLuint, GLint); +alias fp_glVertexAttribI2i = void function(GLuint, GLint, GLint); +alias fp_glVertexAttribI3i = void function(GLuint, GLint, GLint, GLint); +alias fp_glVertexAttribI4i = void function(GLuint, GLint, GLint, GLint, GLint); +alias fp_glVertexAttribI1ui = void function(GLuint, GLuint); +alias fp_glVertexAttribI2ui = void function(GLuint, GLuint, GLuint); +alias fp_glVertexAttribI3ui = void function(GLuint, GLuint, GLuint, GLuint); +alias fp_glVertexAttribI4ui = void function(GLuint, GLuint, GLuint, GLuint, GLuint); +alias fp_glVertexAttribI1iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI2iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI3iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI4iv = void function(GLuint, const(GLint)*); +alias fp_glVertexAttribI1uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI2uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI3uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI4uiv = void function(GLuint, const(GLuint)*); +alias fp_glVertexAttribI4bv = void function(GLuint, const(GLbyte)*); +alias fp_glVertexAttribI4sv = void function(GLuint, const(GLshort)*); +alias fp_glVertexAttribI4ubv = void function(GLuint, const(GLubyte)*); +alias fp_glVertexAttribI4usv = void function(GLuint, const(GLushort)*); +alias fp_glGetUniformuiv = void function(GLuint, GLint, GLuint*); +alias fp_glBindFragDataLocation = void function(GLuint, GLuint, const(GLchar)*); +alias fp_glGetFragDataLocation = GLint function(GLuint, const(GLchar)*); +alias fp_glUniform1ui = void function(GLint, GLuint); +alias fp_glUniform2ui = void function(GLint, GLuint, GLuint); +alias fp_glUniform3ui = void function(GLint, GLuint, GLuint, GLuint); +alias fp_glUniform4ui = void function(GLint, GLuint, GLuint, GLuint, GLuint); +alias fp_glUniform1uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glUniform2uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glUniform3uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glUniform4uiv = void function(GLint, GLsizei, const(GLuint)*); +alias fp_glTexParameterIiv = void function(GLenum, GLenum, const(GLint)*); +alias fp_glTexParameterIuiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glGetTexParameterIiv = void function(GLenum, GLenum, GLint*); +alias fp_glGetTexParameterIuiv = void function(GLenum, GLenum, GLuint*); +alias fp_glClearBufferiv = void function(GLenum, GLint, const(GLint)*); +alias fp_glClearBufferuiv = void function(GLenum, GLint, const(GLuint)*); +alias fp_glClearBufferfv = void function(GLenum, GLint, const(GLfloat)*); +alias fp_glClearBufferfi = void function(GLenum, GLint, GLfloat, GLint); +alias fp_glGetStringi = const(GLubyte)* function(GLenum, GLuint); +alias fp_glIsRenderbuffer = GLboolean function(GLuint); +alias fp_glBindRenderbuffer = void function(GLenum, GLuint); +alias fp_glDeleteRenderbuffers = void function(GLsizei, const(GLuint)*); +alias fp_glGenRenderbuffers = void function(GLsizei, GLuint*); +alias fp_glRenderbufferStorage = void function(GLenum, GLenum, GLsizei, GLsizei); +alias fp_glGetRenderbufferParameteriv = void function(GLenum, GLenum, GLint*); +alias fp_glIsFramebuffer = GLboolean function(GLuint); +alias fp_glBindFramebuffer = void function(GLenum, GLuint); +alias fp_glDeleteFramebuffers = void function(GLsizei, const(GLuint)*); +alias fp_glGenFramebuffers = void function(GLsizei, GLuint*); +alias fp_glCheckFramebufferStatus = GLenum function(GLenum); +alias fp_glFramebufferTexture1D = void function(GLenum, GLenum, GLenum, GLuint, GLint); +alias fp_glFramebufferTexture2D = void function(GLenum, GLenum, GLenum, GLuint, GLint); +alias fp_glFramebufferTexture3D = void function(GLenum, GLenum, GLenum, GLuint, GLint, GLint); +alias fp_glFramebufferRenderbuffer = void function(GLenum, GLenum, GLenum, GLuint); +alias fp_glGetFramebufferAttachmentParameteriv = void function(GLenum, GLenum, GLenum, GLint*); +alias fp_glGenerateMipmap = void function(GLenum); +alias fp_glBlitFramebuffer = void function(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum); +alias fp_glRenderbufferStorageMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei); +alias fp_glFramebufferTextureLayer = void function(GLenum, GLenum, GLuint, GLint, GLint); +alias fp_glMapBufferRange = void* function(GLenum, GLintptr, GLsizeiptr, GLbitfield); +alias fp_glFlushMappedBufferRange = void function(GLenum, GLintptr, GLsizeiptr); +alias fp_glBindVertexArray = void function(GLuint); +alias fp_glDeleteVertexArrays = void function(GLsizei, const(GLuint)*); +alias fp_glGenVertexArrays = void function(GLsizei, GLuint*); +alias fp_glIsVertexArray = GLboolean function(GLuint); +alias fp_glDrawArraysInstanced = void function(GLenum, GLint, GLsizei, GLsizei); +alias fp_glDrawElementsInstanced = void function(GLenum, GLsizei, GLenum, const(void)*, GLsizei); +alias fp_glTexBuffer = void function(GLenum, GLenum, GLuint); +alias fp_glPrimitiveRestartIndex = void function(GLuint); +alias fp_glCopyBufferSubData = void function(GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr); +alias fp_glGetUniformIndices = void function(GLuint, GLsizei, const(GLchar*)*, GLuint*); +alias fp_glGetActiveUniformsiv = void function(GLuint, GLsizei, const(GLuint)*, GLenum, GLint*); +alias fp_glGetActiveUniformName = void function(GLuint, GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glGetUniformBlockIndex = GLuint function(GLuint, const(GLchar)*); +alias fp_glGetActiveUniformBlockiv = void function(GLuint, GLuint, GLenum, GLint*); +alias fp_glGetActiveUniformBlockName = void function(GLuint, GLuint, GLsizei, GLsizei*, GLchar*); +alias fp_glUniformBlockBinding = void function(GLuint, GLuint, GLuint); +alias fp_glDrawElementsBaseVertex = void function(GLenum, GLsizei, GLenum, const(void)*, GLint); +alias fp_glDrawRangeElementsBaseVertex = void function(GLenum, GLuint, GLuint, GLsizei, GLenum, const(void)*, GLint); +alias fp_glDrawElementsInstancedBaseVertex = void function(GLenum, GLsizei, GLenum, const(void)*, GLsizei, GLint); +alias fp_glMultiDrawElementsBaseVertex = void function(GLenum, const(GLsizei)*, GLenum, const(void*)*, GLsizei, const(GLint)*); +alias fp_glProvokingVertex = void function(GLenum); +alias fp_glFenceSync = GLsync function(GLenum, GLbitfield); +alias fp_glIsSync = GLboolean function(GLsync); +alias fp_glDeleteSync = void function(GLsync); +alias fp_glClientWaitSync = GLenum function(GLsync, GLbitfield, GLuint64); +alias fp_glWaitSync = void function(GLsync, GLbitfield, GLuint64); +alias fp_glGetInteger64v = void function(GLenum, GLint64*); +alias fp_glGetSynciv = void function(GLsync, GLenum, GLsizei, GLsizei*, GLint*); +alias fp_glGetInteger64i_v = void function(GLenum, GLuint, GLint64*); +alias fp_glGetBufferParameteri64v = void function(GLenum, GLenum, GLint64*); +alias fp_glFramebufferTexture = void function(GLenum, GLenum, GLuint, GLint); +alias fp_glTexImage2DMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean); +alias fp_glTexImage3DMultisample = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean); +alias fp_glGetMultisamplefv = void function(GLenum, GLuint, GLfloat*); +alias fp_glSampleMaski = void function(GLuint, GLbitfield); +alias fp_glBindFragDataLocationIndexed = void function(GLuint, GLuint, GLuint, const(GLchar)*); +alias fp_glGetFragDataIndex = GLint function(GLuint, const(GLchar)*); +alias fp_glGenSamplers = void function(GLsizei, GLuint*); +alias fp_glDeleteSamplers = void function(GLsizei, const(GLuint)*); +alias fp_glIsSampler = GLboolean function(GLuint); +alias fp_glBindSampler = void function(GLuint, GLuint); +alias fp_glSamplerParameteri = void function(GLuint, GLenum, GLint); +alias fp_glSamplerParameteriv = void function(GLuint, GLenum, const(GLint)*); +alias fp_glSamplerParameterf = void function(GLuint, GLenum, GLfloat); +alias fp_glSamplerParameterfv = void function(GLuint, GLenum, const(GLfloat)*); +alias fp_glSamplerParameterIiv = void function(GLuint, GLenum, const(GLint)*); +alias fp_glSamplerParameterIuiv = void function(GLuint, GLenum, const(GLuint)*); +alias fp_glGetSamplerParameteriv = void function(GLuint, GLenum, GLint*); +alias fp_glGetSamplerParameterIiv = void function(GLuint, GLenum, GLint*); +alias fp_glGetSamplerParameterfv = void function(GLuint, GLenum, GLfloat*); +alias fp_glGetSamplerParameterIuiv = void function(GLuint, GLenum, GLuint*); +alias fp_glQueryCounter = void function(GLuint, GLenum); +alias fp_glGetQueryObjecti64v = void function(GLuint, GLenum, GLint64*); +alias fp_glGetQueryObjectui64v = void function(GLuint, GLenum, GLuint64*); +alias fp_glVertexAttribDivisor = void function(GLuint, GLuint); +alias fp_glVertexAttribP1ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP1uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexAttribP2ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP2uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexAttribP3ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP3uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexAttribP4ui = void function(GLuint, GLenum, GLboolean, GLuint); +alias fp_glVertexAttribP4uiv = void function(GLuint, GLenum, GLboolean, const(GLuint)*); +alias fp_glVertexP2ui = void function(GLenum, GLuint); +alias fp_glVertexP2uiv = void function(GLenum, const(GLuint)*); +alias fp_glVertexP3ui = void function(GLenum, GLuint); +alias fp_glVertexP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glVertexP4ui = void function(GLenum, GLuint); +alias fp_glVertexP4uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP1ui = void function(GLenum, GLuint); +alias fp_glTexCoordP1uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP2ui = void function(GLenum, GLuint); +alias fp_glTexCoordP2uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP3ui = void function(GLenum, GLuint); +alias fp_glTexCoordP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glTexCoordP4ui = void function(GLenum, GLuint); +alias fp_glTexCoordP4uiv = void function(GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP1ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP1uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP2ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP2uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP3ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP3uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glMultiTexCoordP4ui = void function(GLenum, GLenum, GLuint); +alias fp_glMultiTexCoordP4uiv = void function(GLenum, GLenum, const(GLuint)*); +alias fp_glNormalP3ui = void function(GLenum, GLuint); +alias fp_glNormalP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glColorP3ui = void function(GLenum, GLuint); +alias fp_glColorP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glColorP4ui = void function(GLenum, GLuint); +alias fp_glColorP4uiv = void function(GLenum, const(GLuint)*); +alias fp_glSecondaryColorP3ui = void function(GLenum, GLuint); +alias fp_glSecondaryColorP3uiv = void function(GLenum, const(GLuint)*); +alias fp_glClearDepthf = void function(GLfloat); +alias fp_glDepthRangef = void function(GLfloat, GLfloat); +alias fp_glGetShaderPrecisionFormat = void function(GLenum, GLenum, GLint*, GLint*); +alias fp_glReleaseShaderCompiler = void function(); +alias fp_glShaderBinary = void function(GLsizei, const(GLuint)*, GLenum, const(void)*, GLsizei); +alias fp_glBindTransformFeedback = void function(GLenum, GLuint); +alias fp_glDeleteTransformFeedbacks = void function(GLsizei, const(GLuint)*); +alias fp_glGenTransformFeedbacks = void function(GLsizei, GLuint*); +alias fp_glIsTransformFeedback = GLboolean function(GLuint); +alias fp_glPauseTransformFeedback = void function(); +alias fp_glResumeTransformFeedback = void function(); +alias fp_glGetProgramBinary = void function(GLuint, GLsizei, GLsizei*, GLenum*, void*); +alias fp_glProgramBinary = void function(GLuint, GLenum, const(void)*, GLsizei); +alias fp_glProgramParameteri = void function(GLuint, GLenum, GLint); +alias fp_glInvalidateFramebuffer = void function(GLenum, GLsizei, const(GLenum)*); +alias fp_glInvalidateSubFramebuffer = void function(GLenum, GLsizei, const(GLenum)*, GLint, GLint, GLsizei, GLsizei); +alias fp_glTexStorage2D = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei); +alias fp_glTexStorage3D = void function(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei); +alias fp_glGetInternalformativ = void function(GLenum, GLenum, GLenum, GLsizei, GLint*); +} +__gshared { +fp_glCopyTexImage1D glCopyTexImage1D; +fp_glVertexAttribI3ui glVertexAttribI3ui; +fp_glWindowPos2s glWindowPos2s; +fp_glWindowPos2i glWindowPos2i; +fp_glWindowPos2f glWindowPos2f; +fp_glWindowPos2d glWindowPos2d; +fp_glVertex2fv glVertex2fv; +fp_glIndexi glIndexi; +fp_glFramebufferRenderbuffer glFramebufferRenderbuffer; +fp_glRectdv glRectdv; +fp_glCompressedTexSubImage3D glCompressedTexSubImage3D; +fp_glEvalCoord2d glEvalCoord2d; +fp_glEvalCoord2f glEvalCoord2f; +fp_glIndexd glIndexd; +fp_glVertexAttrib1sv glVertexAttrib1sv; +fp_glIndexf glIndexf; +fp_glBindSampler glBindSampler; +fp_glLineWidth glLineWidth; +fp_glColorP3uiv glColorP3uiv; +fp_glGetIntegeri_v glGetIntegeri_v; +fp_glGetMapfv glGetMapfv; +fp_glIndexs glIndexs; +fp_glCompileShader glCompileShader; +fp_glGetTransformFeedbackVarying glGetTransformFeedbackVarying; +fp_glWindowPos2iv glWindowPos2iv; +fp_glIndexfv glIndexfv; +fp_glFogiv glFogiv; +fp_glStencilMaskSeparate glStencilMaskSeparate; +fp_glRasterPos2fv glRasterPos2fv; +fp_glLightModeliv glLightModeliv; +fp_glDepthRangef glDepthRangef; +fp_glColor4ui glColor4ui; +fp_glSecondaryColor3fv glSecondaryColor3fv; +fp_glMultiTexCoordP3ui glMultiTexCoordP3ui; +fp_glFogfv glFogfv; +fp_glVertexP4ui glVertexP4ui; +fp_glEnablei glEnablei; +fp_glVertex4iv glVertex4iv; +fp_glEvalCoord1fv glEvalCoord1fv; +fp_glWindowPos2sv glWindowPos2sv; +fp_glVertexAttribP4ui glVertexAttribP4ui; +fp_glCreateShader glCreateShader; +fp_glIsBuffer glIsBuffer; +fp_glGetMultisamplefv glGetMultisamplefv; +fp_glGenRenderbuffers glGenRenderbuffers; +fp_glCopyTexSubImage2D glCopyTexSubImage2D; +fp_glCompressedTexImage2D glCompressedTexImage2D; +fp_glVertexAttrib1f glVertexAttrib1f; +fp_glBlendFuncSeparate glBlendFuncSeparate; +fp_glVertex4fv glVertex4fv; +fp_glBindTexture glBindTexture; +fp_glVertexAttrib1s glVertexAttrib1s; +fp_glTexCoord2fv glTexCoord2fv; +fp_glSampleMaski glSampleMaski; +fp_glVertexP2ui glVertexP2ui; +fp_glDrawRangeElementsBaseVertex glDrawRangeElementsBaseVertex; +fp_glTexCoord4fv glTexCoord4fv; +fp_glUniformMatrix3x2fv glUniformMatrix3x2fv; +fp_glPointSize glPointSize; +fp_glVertexAttrib2dv glVertexAttrib2dv; +fp_glDeleteProgram glDeleteProgram; +fp_glColor4bv glColor4bv; +fp_glRasterPos2f glRasterPos2f; +fp_glRasterPos2d glRasterPos2d; +fp_glLoadIdentity glLoadIdentity; +fp_glRasterPos2i glRasterPos2i; +fp_glRenderbufferStorage glRenderbufferStorage; +fp_glUniformMatrix4x3fv glUniformMatrix4x3fv; +fp_glColor3b glColor3b; +fp_glClearBufferfv glClearBufferfv; +fp_glEdgeFlag glEdgeFlag; +fp_glDeleteSamplers glDeleteSamplers; +fp_glVertex3d glVertex3d; +fp_glVertex3f glVertex3f; +fp_glVertex3i glVertex3i; +fp_glColor3i glColor3i; +fp_glUniform3f glUniform3f; +fp_glVertexAttrib4ubv glVertexAttrib4ubv; +fp_glColor3s glColor3s; +fp_glVertex3s glVertex3s; +fp_glTexCoordP2ui glTexCoordP2ui; +fp_glColorMaski glColorMaski; +fp_glClearBufferfi glClearBufferfi; +fp_glTexCoord1iv glTexCoord1iv; +fp_glBlitFramebuffer glBlitFramebuffer; +fp_glPauseTransformFeedback glPauseTransformFeedback; +fp_glMultiTexCoordP2ui glMultiTexCoordP2ui; +fp_glGetSamplerParameterIiv glGetSamplerParameterIiv; +fp_glGetFragDataIndex glGetFragDataIndex; +fp_glTexStorage3D glTexStorage3D; +fp_glVertexAttrib3f glVertexAttrib3f; +fp_glVertex2iv glVertex2iv; +fp_glColor3sv glColor3sv; +fp_glGetVertexAttribdv glGetVertexAttribdv; +fp_glUniformMatrix3x4fv glUniformMatrix3x4fv; +fp_glNormalPointer glNormalPointer; +fp_glTexCoordP3uiv glTexCoordP3uiv; +fp_glVertex4sv glVertex4sv; +fp_glPassThrough glPassThrough; +fp_glMultiTexCoordP4ui glMultiTexCoordP4ui; +fp_glFogi glFogi; +fp_glBegin glBegin; +fp_glEvalCoord2dv glEvalCoord2dv; +fp_glColor3ubv glColor3ubv; +fp_glVertexPointer glVertexPointer; +fp_glSecondaryColor3uiv glSecondaryColor3uiv; +fp_glDeleteFramebuffers glDeleteFramebuffers; +fp_glDrawArrays glDrawArrays; +fp_glUniform1ui glUniform1ui; +fp_glMultiTexCoord1d glMultiTexCoord1d; +fp_glMultiTexCoord1f glMultiTexCoord1f; +fp_glProgramParameteri glProgramParameteri; +fp_glLightfv glLightfv; +fp_glTexCoordP3ui glTexCoordP3ui; +fp_glVertexAttrib3d glVertexAttrib3d; +fp_glClear glClear; +fp_glMultiTexCoord1i glMultiTexCoord1i; +fp_glGetActiveUniformName glGetActiveUniformName; +fp_glMultiTexCoord1s glMultiTexCoord1s; +fp_glIsEnabled glIsEnabled; +fp_glStencilOp glStencilOp; +fp_glGetQueryObjectuiv glGetQueryObjectuiv; +fp_glFramebufferTexture2D glFramebufferTexture2D; +fp_glGetFramebufferAttachmentParameteriv glGetFramebufferAttachmentParameteriv; +fp_glTranslatef glTranslatef; +fp_glVertexAttrib4Nub glVertexAttrib4Nub; +fp_glTranslated glTranslated; +fp_glTexCoord3sv glTexCoord3sv; +fp_glGetFragDataLocation glGetFragDataLocation; +fp_glTexImage1D glTexImage1D; +fp_glVertexP3uiv glVertexP3uiv; +fp_glTexParameteriv glTexParameteriv; +fp_glSecondaryColor3bv glSecondaryColor3bv; +fp_glGetMaterialfv glGetMaterialfv; +fp_glGetTexImage glGetTexImage; +fp_glFogCoordfv glFogCoordfv; +fp_glPixelMapuiv glPixelMapuiv; +fp_glGetShaderInfoLog glGetShaderInfoLog; +fp_glGetQueryObjecti64v glGetQueryObjecti64v; +fp_glGenFramebuffers glGenFramebuffers; +fp_glIndexsv glIndexsv; +fp_glGetAttachedShaders glGetAttachedShaders; +fp_glIsRenderbuffer glIsRenderbuffer; +fp_glVertex3iv glVertex3iv; +fp_glBitmap glBitmap; +fp_glMateriali glMateriali; +fp_glIsVertexArray glIsVertexArray; +fp_glDisableVertexAttribArray glDisableVertexAttribArray; +fp_glGetQueryiv glGetQueryiv; +fp_glTexCoord4f glTexCoord4f; +fp_glTexCoord4d glTexCoord4d; +fp_glGetSamplerParameterfv glGetSamplerParameterfv; +fp_glTexCoord4i glTexCoord4i; +fp_glMaterialf glMaterialf; +fp_glTexCoord4s glTexCoord4s; +fp_glGetUniformIndices glGetUniformIndices; +fp_glIsShader glIsShader; +fp_glMultiTexCoord2s glMultiTexCoord2s; +fp_glVertexAttribI4ubv glVertexAttribI4ubv; +fp_glVertex3dv glVertex3dv; +fp_glGetInteger64v glGetInteger64v; +fp_glPointParameteriv glPointParameteriv; +fp_glEnable glEnable; +fp_glGetActiveUniformsiv glGetActiveUniformsiv; +fp_glColor4fv glColor4fv; +fp_glTexCoord1fv glTexCoord1fv; +fp_glTexCoord2sv glTexCoord2sv; +fp_glVertexAttrib4dv glVertexAttrib4dv; +fp_glMultiTexCoord1dv glMultiTexCoord1dv; +fp_glMultiTexCoord2i glMultiTexCoord2i; +fp_glTexCoord3fv glTexCoord3fv; +fp_glSecondaryColor3usv glSecondaryColor3usv; +fp_glTexGenf glTexGenf; +fp_glMultiTexCoordP3uiv glMultiTexCoordP3uiv; +fp_glVertexAttribP3ui glVertexAttribP3ui; +fp_glMultiTexCoordP1ui glMultiTexCoordP1ui; +fp_glGetPointerv glGetPointerv; +fp_glPolygonOffset glPolygonOffset; +fp_glGetUniformuiv glGetUniformuiv; +fp_glNormal3fv glNormal3fv; +fp_glSecondaryColor3s glSecondaryColor3s; +fp_glDepthRange glDepthRange; +fp_glFrustum glFrustum; +fp_glMultiTexCoord4sv glMultiTexCoord4sv; +fp_glDrawBuffer glDrawBuffer; +fp_glPushMatrix glPushMatrix; +fp_glRasterPos3fv glRasterPos3fv; +fp_glOrtho glOrtho; +fp_glDrawElementsInstanced glDrawElementsInstanced; +fp_glWindowPos3sv glWindowPos3sv; +fp_glClearIndex glClearIndex; +fp_glMap1d glMap1d; +fp_glMap1f glMap1f; +fp_glFlush glFlush; +fp_glGetRenderbufferParameteriv glGetRenderbufferParameteriv; +fp_glIndexiv glIndexiv; +fp_glRasterPos3sv glRasterPos3sv; +fp_glGetVertexAttribPointerv glGetVertexAttribPointerv; +fp_glPixelZoom glPixelZoom; +fp_glFenceSync glFenceSync; +fp_glDeleteVertexArrays glDeleteVertexArrays; +fp_glColorP3ui glColorP3ui; +fp_glVertexAttrib3sv glVertexAttrib3sv; +fp_glBeginConditionalRender glBeginConditionalRender; +fp_glGetShaderPrecisionFormat glGetShaderPrecisionFormat; +fp_glDrawElementsBaseVertex glDrawElementsBaseVertex; +fp_glGetTexLevelParameteriv glGetTexLevelParameteriv; +fp_glLighti glLighti; +fp_glMultiTexCoordP4uiv glMultiTexCoordP4uiv; +fp_glLightf glLightf; +fp_glGetAttribLocation glGetAttribLocation; +fp_glStencilFuncSeparate glStencilFuncSeparate; +fp_glGenSamplers glGenSamplers; +fp_glClampColor glClampColor; +fp_glUniform4iv glUniform4iv; +fp_glClearStencil glClearStencil; +fp_glTexCoordP1uiv glTexCoordP1uiv; +fp_glMultiTexCoord3fv glMultiTexCoord3fv; +fp_glGetPixelMapuiv glGetPixelMapuiv; +fp_glGenTextures glGenTextures; +fp_glTexCoord4iv glTexCoord4iv; +fp_glGetTexParameterIuiv glGetTexParameterIuiv; +fp_glIndexPointer glIndexPointer; +fp_glVertexAttrib4Nbv glVertexAttrib4Nbv; +fp_glIsSync glIsSync; +fp_glVertex2f glVertex2f; +fp_glVertex2d glVertex2d; +fp_glDeleteRenderbuffers glDeleteRenderbuffers; +fp_glUniform2i glUniform2i; +fp_glMapGrid2d glMapGrid2d; +fp_glMapGrid2f glMapGrid2f; +fp_glTexCoordP4ui glTexCoordP4ui; +fp_glVertex2i glVertex2i; +fp_glVertexAttribPointer glVertexAttribPointer; +fp_glFramebufferTextureLayer glFramebufferTextureLayer; +fp_glVertex2s glVertex2s; +fp_glNormal3bv glNormal3bv; +fp_glVertexAttrib4Nuiv glVertexAttrib4Nuiv; +fp_glFlushMappedBufferRange glFlushMappedBufferRange; +fp_glTexStorage2D glTexStorage2D; +fp_glSecondaryColor3sv glSecondaryColor3sv; +fp_glVertex3sv glVertex3sv; +fp_glGenQueries glGenQueries; +fp_glGetPixelMapfv glGetPixelMapfv; +fp_glTexEnvf glTexEnvf; +fp_glVertexAttribP1ui glVertexAttribP1ui; +fp_glTexSubImage3D glTexSubImage3D; +fp_glGetInteger64i_v glGetInteger64i_v; +fp_glFogCoordd glFogCoordd; +fp_glFogCoordf glFogCoordf; +fp_glCopyTexImage2D glCopyTexImage2D; +fp_glTexEnvi glTexEnvi; +fp_glMultiTexCoord1iv glMultiTexCoord1iv; +fp_glIsEnabledi glIsEnabledi; +fp_glSecondaryColorP3ui glSecondaryColorP3ui; +fp_glVertexAttribI2i glVertexAttribI2i; +fp_glBindFragDataLocationIndexed glBindFragDataLocationIndexed; +fp_glMultiTexCoord2dv glMultiTexCoord2dv; +fp_glUniform2iv glUniform2iv; +fp_glVertexAttrib1fv glVertexAttrib1fv; +fp_glGetInternalformativ glGetInternalformativ; +fp_glUniform4uiv glUniform4uiv; +fp_glMatrixMode glMatrixMode; +fp_glFeedbackBuffer glFeedbackBuffer; +fp_glGetMapiv glGetMapiv; +fp_glFramebufferTexture1D glFramebufferTexture1D; +fp_glGetShaderiv glGetShaderiv; +fp_glMultiTexCoord2d glMultiTexCoord2d; +fp_glMultiTexCoord2f glMultiTexCoord2f; +fp_glInvalidateFramebuffer glInvalidateFramebuffer; +fp_glBindFragDataLocation glBindFragDataLocation; +fp_glPrioritizeTextures glPrioritizeTextures; +fp_glCallList glCallList; +fp_glSecondaryColor3ubv glSecondaryColor3ubv; +fp_glGetDoublev glGetDoublev; +fp_glMultiTexCoord3iv glMultiTexCoord3iv; +fp_glVertexAttrib1d glVertexAttrib1d; +fp_glLightModelf glLightModelf; +fp_glGetUniformiv glGetUniformiv; +fp_glVertex2sv glVertex2sv; +fp_glLightModeli glLightModeli; +fp_glWindowPos3iv glWindowPos3iv; +fp_glMultiTexCoordP1uiv glMultiTexCoordP1uiv; +fp_glUniform3fv glUniform3fv; +fp_glPixelStorei glPixelStorei; +fp_glCallLists glCallLists; +fp_glInvalidateSubFramebuffer glInvalidateSubFramebuffer; +fp_glMapBuffer glMapBuffer; +fp_glSecondaryColor3d glSecondaryColor3d; +fp_glTexCoord3i glTexCoord3i; +fp_glMultiTexCoord4fv glMultiTexCoord4fv; +fp_glRasterPos3i glRasterPos3i; +fp_glSecondaryColor3b glSecondaryColor3b; +fp_glRasterPos3d glRasterPos3d; +fp_glRasterPos3f glRasterPos3f; +fp_glCompressedTexImage3D glCompressedTexImage3D; +fp_glTexCoord3f glTexCoord3f; +fp_glDeleteSync glDeleteSync; +fp_glTexCoord3d glTexCoord3d; +fp_glTexImage2DMultisample glTexImage2DMultisample; +fp_glGetVertexAttribiv glGetVertexAttribiv; +fp_glMultiDrawElements glMultiDrawElements; +fp_glVertexAttrib3fv glVertexAttrib3fv; +fp_glTexCoord3s glTexCoord3s; +fp_glUniform3iv glUniform3iv; +fp_glRasterPos3s glRasterPos3s; +fp_glPolygonMode glPolygonMode; +fp_glDrawBuffers glDrawBuffers; +fp_glGetActiveUniformBlockiv glGetActiveUniformBlockiv; +fp_glAreTexturesResident glAreTexturesResident; +fp_glIsList glIsList; +fp_glRasterPos2sv glRasterPos2sv; +fp_glRasterPos4sv glRasterPos4sv; +fp_glColor4s glColor4s; +fp_glGetProgramBinary glGetProgramBinary; +fp_glUseProgram glUseProgram; +fp_glLineStipple glLineStipple; +fp_glMultiTexCoord1sv glMultiTexCoord1sv; +fp_glGetProgramInfoLog glGetProgramInfoLog; +fp_glGetBufferParameteriv glGetBufferParameteriv; +fp_glMultiTexCoord2iv glMultiTexCoord2iv; +fp_glUniformMatrix2x4fv glUniformMatrix2x4fv; +fp_glBindVertexArray glBindVertexArray; +fp_glColor4b glColor4b; +fp_glSecondaryColor3f glSecondaryColor3f; +fp_glColor4f glColor4f; +fp_glColor4d glColor4d; +fp_glColor4i glColor4i; +fp_glSamplerParameterIiv glSamplerParameterIiv; +fp_glMultiDrawElementsBaseVertex glMultiDrawElementsBaseVertex; +fp_glRasterPos3iv glRasterPos3iv; +fp_glVertex2dv glVertex2dv; +fp_glTexCoord4sv glTexCoord4sv; +fp_glUniform2uiv glUniform2uiv; +fp_glCompressedTexSubImage1D glCompressedTexSubImage1D; +fp_glFinish glFinish; +fp_glGetBooleanv glGetBooleanv; +fp_glDeleteShader glDeleteShader; +fp_glDrawElements glDrawElements; +fp_glRasterPos2s glRasterPos2s; +fp_glGetMapdv glGetMapdv; +fp_glVertexAttrib4Nsv glVertexAttrib4Nsv; +fp_glMaterialfv glMaterialfv; +fp_glViewport glViewport; +fp_glUniform1uiv glUniform1uiv; +fp_glTransformFeedbackVaryings glTransformFeedbackVaryings; +fp_glIndexdv glIndexdv; +fp_glCopyTexSubImage3D glCopyTexSubImage3D; +fp_glTexCoord3iv glTexCoord3iv; +fp_glVertexAttribI3i glVertexAttribI3i; +fp_glClearDepth glClearDepth; +fp_glVertexAttribI4usv glVertexAttribI4usv; +fp_glTexParameterf glTexParameterf; +fp_glTexParameteri glTexParameteri; +fp_glGetShaderSource glGetShaderSource; +fp_glTexBuffer glTexBuffer; +fp_glPopName glPopName; +fp_glValidateProgram glValidateProgram; +fp_glPixelStoref glPixelStoref; +fp_glUniform3uiv glUniform3uiv; +fp_glRasterPos4fv glRasterPos4fv; +fp_glEvalCoord1dv glEvalCoord1dv; +fp_glMultiTexCoordP2uiv glMultiTexCoordP2uiv; +fp_glRecti glRecti; +fp_glColor4ub glColor4ub; +fp_glMultTransposeMatrixf glMultTransposeMatrixf; +fp_glRectf glRectf; +fp_glRectd glRectd; +fp_glNormal3sv glNormal3sv; +fp_glNewList glNewList; +fp_glColor4us glColor4us; +fp_glVertexAttribP1uiv glVertexAttribP1uiv; +fp_glLinkProgram glLinkProgram; +fp_glHint glHint; +fp_glRects glRects; +fp_glTexCoord2dv glTexCoord2dv; +fp_glRasterPos4iv glRasterPos4iv; +fp_glGetString glGetString; +fp_glVertexAttribP2uiv glVertexAttribP2uiv; +fp_glEdgeFlagv glEdgeFlagv; +fp_glDetachShader glDetachShader; +fp_glScalef glScalef; +fp_glEndQuery glEndQuery; +fp_glScaled glScaled; +fp_glEdgeFlagPointer glEdgeFlagPointer; +fp_glCopyPixels glCopyPixels; +fp_glVertexAttribI2ui glVertexAttribI2ui; +fp_glPopAttrib glPopAttrib; +fp_glDeleteTextures glDeleteTextures; +fp_glStencilOpSeparate glStencilOpSeparate; +fp_glDeleteQueries glDeleteQueries; +fp_glNormalP3uiv glNormalP3uiv; +fp_glVertexAttrib4f glVertexAttrib4f; +fp_glVertexAttrib4d glVertexAttrib4d; +fp_glInitNames glInitNames; +fp_glGetBufferParameteri64v glGetBufferParameteri64v; +fp_glColor3dv glColor3dv; +fp_glVertexAttribI1i glVertexAttribI1i; +fp_glGetTexParameteriv glGetTexParameteriv; +fp_glWaitSync glWaitSync; +fp_glVertexAttrib4s glVertexAttrib4s; +fp_glColorMaterial glColorMaterial; +fp_glSampleCoverage glSampleCoverage; +fp_glSamplerParameteri glSamplerParameteri; +fp_glSamplerParameterf glSamplerParameterf; +fp_glUniform1f glUniform1f; +fp_glGetVertexAttribfv glGetVertexAttribfv; +fp_glRenderMode glRenderMode; +fp_glGetCompressedTexImage glGetCompressedTexImage; +fp_glWindowPos2dv glWindowPos2dv; +fp_glUniform1i glUniform1i; +fp_glGetActiveAttrib glGetActiveAttrib; +fp_glUniform3i glUniform3i; +fp_glPixelTransferi glPixelTransferi; +fp_glTexSubImage2D glTexSubImage2D; +fp_glDisable glDisable; +fp_glLogicOp glLogicOp; +fp_glEvalPoint2 glEvalPoint2; +fp_glPixelTransferf glPixelTransferf; +fp_glSecondaryColor3i glSecondaryColor3i; +fp_glUniform4ui glUniform4ui; +fp_glColor3f glColor3f; +fp_glBindFramebuffer glBindFramebuffer; +fp_glGetTexEnvfv glGetTexEnvfv; +fp_glRectfv glRectfv; +fp_glCullFace glCullFace; +fp_glGetLightfv glGetLightfv; +fp_glColor3d glColor3d; +fp_glTexGend glTexGend; +fp_glTexGeni glTexGeni; +fp_glMultiTexCoord3s glMultiTexCoord3s; +fp_glGetStringi glGetStringi; +fp_glMultiTexCoord3i glMultiTexCoord3i; +fp_glMultiTexCoord3f glMultiTexCoord3f; +fp_glMultiTexCoord3d glMultiTexCoord3d; +fp_glAttachShader glAttachShader; +fp_glFogCoorddv glFogCoorddv; +fp_glUniformMatrix2x3fv glUniformMatrix2x3fv; +fp_glGetTexGenfv glGetTexGenfv; +fp_glQueryCounter glQueryCounter; +fp_glFogCoordPointer glFogCoordPointer; +fp_glProvokingVertex glProvokingVertex; +fp_glShaderBinary glShaderBinary; +fp_glFramebufferTexture3D glFramebufferTexture3D; +fp_glTexGeniv glTexGeniv; +fp_glRasterPos2dv glRasterPos2dv; +fp_glSecondaryColor3dv glSecondaryColor3dv; +fp_glClientActiveTexture glClientActiveTexture; +fp_glVertexAttribI4sv glVertexAttribI4sv; +fp_glSecondaryColor3us glSecondaryColor3us; +fp_glNormalP3ui glNormalP3ui; +fp_glTexEnvfv glTexEnvfv; +fp_glReadBuffer glReadBuffer; +fp_glTexParameterIuiv glTexParameterIuiv; +fp_glDrawArraysInstanced glDrawArraysInstanced; +fp_glGenerateMipmap glGenerateMipmap; +fp_glWindowPos3fv glWindowPos3fv; +fp_glLightModelfv glLightModelfv; +fp_glSamplerParameteriv glSamplerParameteriv; +fp_glDeleteLists glDeleteLists; +fp_glGetClipPlane glGetClipPlane; +fp_glVertex4dv glVertex4dv; +fp_glTexCoord2d glTexCoord2d; +fp_glPopMatrix glPopMatrix; +fp_glTexCoord2f glTexCoord2f; +fp_glColor4iv glColor4iv; +fp_glIndexubv glIndexubv; +fp_glUnmapBuffer glUnmapBuffer; +fp_glTexCoord2i glTexCoord2i; +fp_glRasterPos4d glRasterPos4d; +fp_glRasterPos4f glRasterPos4f; +fp_glVertexAttrib3s glVertexAttrib3s; +fp_glTexCoord2s glTexCoord2s; +fp_glBindRenderbuffer glBindRenderbuffer; +fp_glVertex3fv glVertex3fv; +fp_glTexCoord4dv glTexCoord4dv; +fp_glMaterialiv glMaterialiv; +fp_glVertexAttribP4uiv glVertexAttribP4uiv; +fp_glIsProgram glIsProgram; +fp_glVertexAttrib4bv glVertexAttrib4bv; +fp_glVertex4s glVertex4s; +fp_glVertexAttrib4fv glVertexAttrib4fv; +fp_glNormal3dv glNormal3dv; +fp_glReleaseShaderCompiler glReleaseShaderCompiler; +fp_glUniform4i glUniform4i; +fp_glActiveTexture glActiveTexture; +fp_glEnableVertexAttribArray glEnableVertexAttribArray; +fp_glRotated glRotated; +fp_glRotatef glRotatef; +fp_glVertex4i glVertex4i; +fp_glReadPixels glReadPixels; +fp_glVertexAttribI3iv glVertexAttribI3iv; +fp_glLoadName glLoadName; +fp_glUniform4f glUniform4f; +fp_glRenderbufferStorageMultisample glRenderbufferStorageMultisample; +fp_glGenVertexArrays glGenVertexArrays; +fp_glShadeModel glShadeModel; +fp_glMapGrid1d glMapGrid1d; +fp_glGetUniformfv glGetUniformfv; +fp_glMapGrid1f glMapGrid1f; +fp_glSamplerParameterfv glSamplerParameterfv; +fp_glDisableClientState glDisableClientState; +fp_glMultiTexCoord3sv glMultiTexCoord3sv; +fp_glDrawElementsInstancedBaseVertex glDrawElementsInstancedBaseVertex; +fp_glSecondaryColorPointer glSecondaryColorPointer; +fp_glAlphaFunc glAlphaFunc; +fp_glUniform1iv glUniform1iv; +fp_glMultiTexCoord4iv glMultiTexCoord4iv; +fp_glGetQueryObjectiv glGetQueryObjectiv; +fp_glStencilFunc glStencilFunc; +fp_glMultiTexCoord1fv glMultiTexCoord1fv; +fp_glUniformBlockBinding glUniformBlockBinding; +fp_glColor4uiv glColor4uiv; +fp_glRectiv glRectiv; +fp_glColorP4ui glColorP4ui; +fp_glRasterPos3dv glRasterPos3dv; +fp_glEvalMesh2 glEvalMesh2; +fp_glEvalMesh1 glEvalMesh1; +fp_glTexCoordPointer glTexCoordPointer; +fp_glVertexAttrib4Nubv glVertexAttrib4Nubv; +fp_glVertexAttribI4iv glVertexAttribI4iv; +fp_glEvalCoord2fv glEvalCoord2fv; +fp_glColor4ubv glColor4ubv; +fp_glLoadTransposeMatrixd glLoadTransposeMatrixd; +fp_glLoadTransposeMatrixf glLoadTransposeMatrixf; +fp_glVertexAttribI4i glVertexAttribI4i; +fp_glRasterPos2iv glRasterPos2iv; +fp_glGetBufferSubData glGetBufferSubData; +fp_glTexEnviv glTexEnviv; +fp_glBlendEquationSeparate glBlendEquationSeparate; +fp_glVertexAttribI1ui glVertexAttribI1ui; +fp_glGenBuffers glGenBuffers; +fp_glSelectBuffer glSelectBuffer; +fp_glVertexAttrib2sv glVertexAttrib2sv; +fp_glPushAttrib glPushAttrib; +fp_glVertexAttribIPointer glVertexAttribIPointer; +fp_glBlendFunc glBlendFunc; +fp_glCreateProgram glCreateProgram; +fp_glTexImage3D glTexImage3D; +fp_glIsFramebuffer glIsFramebuffer; +fp_glLightiv glLightiv; +fp_glPrimitiveRestartIndex glPrimitiveRestartIndex; +fp_glTexGenfv glTexGenfv; +fp_glEnd glEnd; +fp_glDeleteBuffers glDeleteBuffers; +fp_glScissor glScissor; +fp_glTexCoordP4uiv glTexCoordP4uiv; +fp_glClipPlane glClipPlane; +fp_glPushName glPushName; +fp_glTexGendv glTexGendv; +fp_glIndexub glIndexub; +fp_glVertexP2uiv glVertexP2uiv; +fp_glSecondaryColor3iv glSecondaryColor3iv; +fp_glRasterPos4i glRasterPos4i; +fp_glMultTransposeMatrixd glMultTransposeMatrixd; +fp_glClearColor glClearColor; +fp_glVertexAttrib4uiv glVertexAttrib4uiv; +fp_glNormal3s glNormal3s; +fp_glVertexAttrib4Niv glVertexAttrib4Niv; +fp_glClearBufferiv glClearBufferiv; +fp_glPointParameteri glPointParameteri; +fp_glColorP4uiv glColorP4uiv; +fp_glBlendColor glBlendColor; +fp_glWindowPos3d glWindowPos3d; +fp_glVertexAttribI2uiv glVertexAttribI2uiv; +fp_glSamplerParameterIuiv glSamplerParameterIuiv; +fp_glUniform3ui glUniform3ui; +fp_glColor4dv glColor4dv; +fp_glVertexAttribI4uiv glVertexAttribI4uiv; +fp_glPointParameterfv glPointParameterfv; +fp_glResumeTransformFeedback glResumeTransformFeedback; +fp_glUniform2fv glUniform2fv; +fp_glSecondaryColor3ub glSecondaryColor3ub; +fp_glSecondaryColor3ui glSecondaryColor3ui; +fp_glTexCoord3dv glTexCoord3dv; +fp_glGetSamplerParameterIuiv glGetSamplerParameterIuiv; +fp_glBindBufferRange glBindBufferRange; +fp_glNormal3iv glNormal3iv; +fp_glWindowPos3s glWindowPos3s; +fp_glPointParameterf glPointParameterf; +fp_glClearDepthf glClearDepthf; +fp_glGetVertexAttribIuiv glGetVertexAttribIuiv; +fp_glWindowPos3i glWindowPos3i; +fp_glMultiTexCoord4s glMultiTexCoord4s; +fp_glWindowPos3f glWindowPos3f; +fp_glGenTransformFeedbacks glGenTransformFeedbacks; +fp_glColor3us glColor3us; +fp_glColor3uiv glColor3uiv; +fp_glVertexAttrib4Nusv glVertexAttrib4Nusv; +fp_glGetLightiv glGetLightiv; +fp_glDepthFunc glDepthFunc; +fp_glCompressedTexSubImage2D glCompressedTexSubImage2D; +fp_glListBase glListBase; +fp_glMultiTexCoord4f glMultiTexCoord4f; +fp_glColor3ub glColor3ub; +fp_glMultiTexCoord4d glMultiTexCoord4d; +fp_glVertexAttribI4bv glVertexAttribI4bv; +fp_glGetTexParameterfv glGetTexParameterfv; +fp_glColor3ui glColor3ui; +fp_glMultiTexCoord4i glMultiTexCoord4i; +fp_glGetPolygonStipple glGetPolygonStipple; +fp_glClientWaitSync glClientWaitSync; +fp_glVertexAttribI4ui glVertexAttribI4ui; +fp_glMultiTexCoord4dv glMultiTexCoord4dv; +fp_glColorMask glColorMask; +fp_glTexParameterIiv glTexParameterIiv; +fp_glBlendEquation glBlendEquation; +fp_glGetUniformLocation glGetUniformLocation; +fp_glGetSamplerParameteriv glGetSamplerParameteriv; +fp_glRasterPos4s glRasterPos4s; +fp_glEndTransformFeedback glEndTransformFeedback; +fp_glVertexAttrib4usv glVertexAttrib4usv; +fp_glMultiTexCoord3dv glMultiTexCoord3dv; +fp_glColor4sv glColor4sv; +fp_glPopClientAttrib glPopClientAttrib; +fp_glBeginTransformFeedback glBeginTransformFeedback; +fp_glFogf glFogf; +fp_glVertexAttribI1iv glVertexAttribI1iv; +fp_glProgramBinary glProgramBinary; +fp_glIsSampler glIsSampler; +fp_glVertexP3ui glVertexP3ui; +fp_glVertexAttribDivisor glVertexAttribDivisor; +fp_glColor3iv glColor3iv; +fp_glCompressedTexImage1D glCompressedTexImage1D; +fp_glDeleteTransformFeedbacks glDeleteTransformFeedbacks; +fp_glCopyTexSubImage1D glCopyTexSubImage1D; +fp_glTexCoord1i glTexCoord1i; +fp_glCheckFramebufferStatus glCheckFramebufferStatus; +fp_glTexCoord1d glTexCoord1d; +fp_glTexCoord1f glTexCoord1f; +fp_glEndConditionalRender glEndConditionalRender; +fp_glEnableClientState glEnableClientState; +fp_glBindAttribLocation glBindAttribLocation; +fp_glUniformMatrix4x2fv glUniformMatrix4x2fv; +fp_glMultiTexCoord2sv glMultiTexCoord2sv; +fp_glVertexAttrib1dv glVertexAttrib1dv; +fp_glDrawRangeElements glDrawRangeElements; +fp_glTexCoord1s glTexCoord1s; +fp_glBindBufferBase glBindBufferBase; +fp_glBufferSubData glBufferSubData; +fp_glVertexAttrib4iv glVertexAttrib4iv; +fp_glGenLists glGenLists; +fp_glColor3bv glColor3bv; +fp_glMapBufferRange glMapBufferRange; +fp_glFramebufferTexture glFramebufferTexture; +fp_glGetTexGendv glGetTexGendv; +fp_glMultiDrawArrays glMultiDrawArrays; +fp_glEndList glEndList; +fp_glVertexP4uiv glVertexP4uiv; +fp_glUniform2ui glUniform2ui; +fp_glVertexAttribI2iv glVertexAttribI2iv; +fp_glColor3usv glColor3usv; +fp_glWindowPos2fv glWindowPos2fv; +fp_glDisablei glDisablei; +fp_glIndexMask glIndexMask; +fp_glPushClientAttrib glPushClientAttrib; +fp_glShaderSource glShaderSource; +fp_glGetActiveUniformBlockName glGetActiveUniformBlockName; +fp_glVertexAttribI3uiv glVertexAttribI3uiv; +fp_glIsTransformFeedback glIsTransformFeedback; +fp_glClearAccum glClearAccum; +fp_glGetSynciv glGetSynciv; +fp_glTexCoordP2uiv glTexCoordP2uiv; +fp_glUniform2f glUniform2f; +fp_glBeginQuery glBeginQuery; +fp_glGetUniformBlockIndex glGetUniformBlockIndex; +fp_glBindBuffer glBindBuffer; +fp_glMap2d glMap2d; +fp_glMap2f glMap2f; +fp_glVertex4d glVertex4d; +fp_glUniformMatrix2fv glUniformMatrix2fv; +fp_glTexCoord1sv glTexCoord1sv; +fp_glBufferData glBufferData; +fp_glEvalPoint1 glEvalPoint1; +fp_glGetTexParameterIiv glGetTexParameterIiv; +fp_glTexCoord1dv glTexCoord1dv; +fp_glTexCoordP1ui glTexCoordP1ui; +fp_glGetError glGetError; +fp_glGetTexEnviv glGetTexEnviv; +fp_glGetProgramiv glGetProgramiv; +fp_glVertexAttribP2ui glVertexAttribP2ui; +fp_glGetFloatv glGetFloatv; +fp_glTexSubImage1D glTexSubImage1D; +fp_glMultiTexCoord2fv glMultiTexCoord2fv; +fp_glVertexAttrib2fv glVertexAttrib2fv; +fp_glEvalCoord1d glEvalCoord1d; +fp_glGetTexLevelParameterfv glGetTexLevelParameterfv; +fp_glEvalCoord1f glEvalCoord1f; +fp_glPixelMapfv glPixelMapfv; +fp_glVertexAttribP3uiv glVertexAttribP3uiv; +fp_glGetPixelMapusv glGetPixelMapusv; +fp_glSecondaryColorP3uiv glSecondaryColorP3uiv; +fp_glGetIntegerv glGetIntegerv; +fp_glAccum glAccum; +fp_glGetBufferPointerv glGetBufferPointerv; +fp_glGetVertexAttribIiv glGetVertexAttribIiv; +fp_glRasterPos4dv glRasterPos4dv; +fp_glTexCoord2iv glTexCoord2iv; +fp_glIsQuery glIsQuery; +fp_glVertexAttrib4sv glVertexAttrib4sv; +fp_glWindowPos3dv glWindowPos3dv; +fp_glTexImage2D glTexImage2D; +fp_glStencilMask glStencilMask; +fp_glDrawPixels glDrawPixels; +fp_glMultMatrixd glMultMatrixd; +fp_glMultMatrixf glMultMatrixf; +fp_glIsTexture glIsTexture; +fp_glGetMaterialiv glGetMaterialiv; +fp_glUniform1fv glUniform1fv; +fp_glLoadMatrixf glLoadMatrixf; +fp_glLoadMatrixd glLoadMatrixd; +fp_glTexParameterfv glTexParameterfv; +fp_glUniformMatrix3fv glUniformMatrix3fv; +fp_glVertex4f glVertex4f; +fp_glRectsv glRectsv; +fp_glColor4usv glColor4usv; +fp_glPolygonStipple glPolygonStipple; +fp_glInterleavedArrays glInterleavedArrays; +fp_glNormal3i glNormal3i; +fp_glNormal3f glNormal3f; +fp_glNormal3d glNormal3d; +fp_glNormal3b glNormal3b; +fp_glPixelMapusv glPixelMapusv; +fp_glGetTexGeniv glGetTexGeniv; +fp_glArrayElement glArrayElement; +fp_glCopyBufferSubData glCopyBufferSubData; +fp_glVertexAttribI1uiv glVertexAttribI1uiv; +fp_glVertexAttrib2d glVertexAttrib2d; +fp_glBindTransformFeedback glBindTransformFeedback; +fp_glVertexAttrib2f glVertexAttrib2f; +fp_glVertexAttrib3dv glVertexAttrib3dv; +fp_glGetQueryObjectui64v glGetQueryObjectui64v; +fp_glDepthMask glDepthMask; +fp_glVertexAttrib2s glVertexAttrib2s; +fp_glColor3fv glColor3fv; +fp_glTexImage3DMultisample glTexImage3DMultisample; +fp_glUniformMatrix4fv glUniformMatrix4fv; +fp_glUniform4fv glUniform4fv; +fp_glGetActiveUniform glGetActiveUniform; +fp_glColorPointer glColorPointer; +fp_glFrontFace glFrontFace; +fp_glGetBooleani_v glGetBooleani_v; +fp_glClearBufferuiv glClearBufferuiv; +} diff --git a/demos/external/sources/glad/gl/gl.d b/demos/external/sources/glad/gl/gl.d new file mode 100644 index 0000000..2659e44 --- /dev/null +++ b/demos/external/sources/glad/gl/gl.d @@ -0,0 +1,404 @@ +module glad.gl.gl; + + +public import glad.gl.types; +public import glad.gl.funcs : +glCopyTexImage1D, glVertexAttribI3ui, glWindowPos2s, glWindowPos2i, glWindowPos2f, +glWindowPos2d, glVertex2fv, glColor4ub, glIndexi, glFramebufferRenderbuffer, +glRectdv, glCompressedTexSubImage3D, glEvalCoord2d, glEvalCoord2f, glIndexd, +glVertexAttrib1sv, glIndexf, glBindSampler, glLineWidth, glColorP3uiv, +glGetIntegeri_v, glGetMapfv, glIndexs, glCompileShader, glGetTransformFeedbackVarying, +glVertex3sv, glIndexfv, glFogiv, glStencilMaskSeparate, glRasterPos2fv, +glLightModeliv, glRectd, glSecondaryColor3fv, glMultiTexCoordP3ui, glFogfv, +glVertexP4ui, glEnablei, glVertex4iv, glEvalCoord1fv, glWindowPos2sv, +glVertexAttribP4ui, glCreateShader, glIsBuffer, glGetMultisamplefv, glGenRenderbuffers, +glCopyTexSubImage2D, glCompressedTexImage2D, glVertexAttrib1f, glBlendFuncSeparate, glVertex4fv, +glDrawBuffers, glVertexAttrib1s, glTexCoord2fv, glSampleMaski, glVertexP2ui, +glTexCoord1i, glTexCoord4fv, glUniformMatrix3x2fv, glPointSize, glVertexAttrib2dv, +glDeleteProgram, glColor4bv, glRasterPos2f, glRasterPos2d, glLoadIdentity, +glRasterPos2i, glUniformMatrix4x3fv, glColor3b, glClearBufferfv, glEdgeFlag, +glFogCoordf, glVertex3d, glVertex3f, glVertex3i, glColor3i, +glUniform3f, glVertexAttrib4ubv, glColor3s, glVertex3s, glTexCoordP2ui, +glColorMaski, glEnableClientState, glClearBufferfi, glTexCoord1iv, glMultiTexCoord1iv, +glMultiTexCoordP2ui, glGetSamplerParameterIiv, glGetFragDataIndex, glRasterPos4i, glVertex2iv, +glColor3sv, glGetVertexAttribdv, glUniformMatrix3x4fv, glNormalPointer, glTexCoordP3uiv, +glVertex4sv, glPassThrough, glMultiTexCoordP4ui, glFogi, glBegin, +glEvalCoord2dv, glColor3ubv, glVertexPointer, glScaled, glDeleteFramebuffers, +glDrawArrays, glUniform1ui, glMultiTexCoord1d, glMultiTexCoord1f, glLightfv, +glClear, glMultiTexCoord1i, glGetActiveUniformName, glMultiTexCoord1s, glStencilOp, +glTexCoord1s, glFramebufferTexture2D, glGetFramebufferAttachmentParameteriv, glTranslatef, glVertexAttrib4Nub, +glTranslated, glTexCoord3sv, glGetFragDataLocation, glTexImage1D, glTexParameteriv, +glCopyPixels, glSecondaryColor3bv, glGetMaterialfv, glGetTexImage, glFogCoordfv, +glVertexAttrib4iv, glPixelMapuiv, glColor4ubv, glGetQueryObjecti64v, glGenFramebuffers, +glIndexsv, glGetAttachedShaders, glIsRenderbuffer, glVertex3iv, glBitmap, +glMateriali, glIsVertexArray, glDisableVertexAttribArray, glGetQueryiv, glTexCoord4f, +glTexCoord4d, glGetSamplerParameterfv, glTexCoord4i, glMaterialf, glTexCoord4s, +glGetUniformIndices, glIsShader, glFeedbackBuffer, glVertexAttribI4ubv, glVertex3dv, +glPointParameteriv, glDisable, glEnable, glGetActiveUniformsiv, glColor4fv, +glTexCoord1fv, glTexCoord2sv, glVertexAttrib4dv, glMultiTexCoord1dv, glGetMapiv, +glTexCoord3fv, glSecondaryColor3usv, glMultiTexCoordP3uiv, glVertexAttribP3ui, glGetPointerv, +glPolygonOffset, glGetUniformuiv, glNormal3fv, glDepthRange, glFrustum, +glMultiTexCoord2f, glDrawBuffer, glPushMatrix, glRasterPos3fv, glOrtho, +glDrawElementsInstanced, glWindowPos3sv, glVertexAttrib4d, glClearIndex, glMap1d, +glMap1f, glFlush, glGetRenderbufferParameteriv, glIndexiv, glRasterPos3sv, +glGetVertexAttribPointerv, glPixelZoom, glDeleteBuffers, glFenceSync, glDeleteVertexArrays, +glColorP3ui, glVertexAttrib3sv, glVertexAttrib4s, glGetTexLevelParameteriv, glLighti, +glMultiTexCoordP4uiv, glLightf, glGetAttribLocation, glStencilFuncSeparate, glGenSamplers, +glClampColor, glUniform4iv, glClearStencil, glVertexAttrib2sv, glMultiTexCoord3fv, +glGetPixelMapuiv, glGenTextures, glTexCoord4iv, glGetTexParameterIuiv, glIndexPointer, +glVertexAttrib4Nbv, glGetQueryObjectiv, glIsSync, glVertex2f, glVertex2d, +glDeleteRenderbuffers, glUniform2i, glMapGrid2d, glMapGrid2f, glShaderSource, +glVertex2i, glVertexAttribPointer, glFramebufferTextureLayer, glVertex2s, glNormal3bv, +glFlushMappedBufferRange, glSecondaryColor3sv, glPointParameteri, glWindowPos2iv, glGenQueries, +glGetPixelMapfv, glTexEnvf, glVertexAttribP1ui, glTexSubImage3D, glGetInteger64i_v, +glFogCoordd, glDeleteSamplers, glCopyTexImage2D, glTexEnvi, glBlitFramebuffer, +glIsEnabledi, glSecondaryColorP3ui, glBindFragDataLocationIndexed, glMultiTexCoord2dv, glUniform2iv, +glUniform4uiv, glMatrixMode, glMultiTexCoord2s, glColor3uiv, glMultiTexCoord2i, +glFramebufferTexture1D, glGetShaderiv, glMultiTexCoord2d, glMultiTexCoord4sv, glBindFragDataLocation, +glPrioritizeTextures, glCallList, glSecondaryColor3ubv, glGetDoublev, glMultiTexCoord3iv, +glVertexAttrib1d, glLightModelf, glVertexAttrib1fv, glVertex2sv, glLightModeli, +glBindBufferRange, glWindowPos3iv, glMultiTexCoordP1uiv, glUniform3fv, glCallLists, +glMapBuffer, glSecondaryColor3d, glTexCoord3i, glMultiTexCoord4fv, glRasterPos3i, +glSecondaryColor3b, glRasterPos3d, glRasterPos3f, glCompressedTexImage3D, glTexCoord3f, +glDeleteSync, glMultiTexCoordP1ui, glGetVertexAttribiv, glSecondaryColor3s, glVertexAttrib3fv, +glTexCoord3s, glUniform3iv, glRasterPos3s, glPolygonMode, glGetActiveUniformBlockiv, +glAreTexturesResident, glIsList, glRasterPos4sv, glCopyTexSubImage3D, glColor4s, +glUseProgram, glLineStipple, glSamplerParameterIuiv, glMultiTexCoord1sv, glGetProgramInfoLog, +glMultiTexCoord2iv, glTexCoord1sv, glBindVertexArray, glColor4b, glSecondaryColor3f, +glColor4f, glColor4d, glColor4i, glMultiDrawElementsBaseVertex, glUniform4fv, +glRasterPos3iv, glVertex2dv, glTexCoord4sv, glUniform2uiv, glCompressedTexSubImage1D, +glFinish, glClipPlane, glDeleteShader, glRasterPos2s, glGetMapdv, +glVertexAttrib4Nsv, glTexGendv, glViewport, glBindBufferBase, glVertexP3uiv, +glTransformFeedbackVaryings, glIndexdv, glTexCoord3d, glTexCoord3iv, glVertexAttribI3i, +glClearDepth, glVertexAttribI4usv, glTexParameterf, glTexParameteri, glGetShaderSource, +glTexBuffer, glPixelStorei, glValidateProgram, glPixelStoref, glSecondaryColor3iv, +glRasterPos4fv, glEvalCoord1dv, glMultiTexCoordP2uiv, glRecti, glMultiDrawElements, +glRectf, glColor4ui, glNormal3sv, glGetFloatv, glColor4us, +glVertexAttribP1uiv, glLinkProgram, glTexSubImage1D, glBindTexture, glRects, +glTexCoord2dv, glRasterPos4iv, glGetString, glVertexAttribP2uiv, glEdgeFlagv, +glDetachShader, glScalef, glEndQuery, glSecondaryColor3uiv, glEdgeFlagPointer, +glVertexAttrib4Nuiv, glVertexAttribI2ui, glPopAttrib, glDeleteTextures, glStencilOpSeparate, +glDeleteQueries, glNormalP3uiv, glVertexAttrib4f, glRenderbufferStorage, glInitNames, +glColor3dv, glPixelMapfv, glGetTexParameteriv, glWaitSync, glBeginConditionalRender, +glDrawElementsBaseVertex, glSampleCoverage, glSamplerParameteri, glSamplerParameterf, glUniform1f, +glGetVertexAttribfv, glRenderMode, glGetCompressedTexImage, glWindowPos2dv, glUniform1i, +glGetActiveAttrib, glUniform3i, glPixelTransferi, glTexSubImage2D, glGetUniformiv, +glLogicOp, glEvalPoint2, glPixelTransferf, glUniform4ui, glColor3f, +glBindFramebuffer, glGetTexEnvfv, glRectfv, glCullFace, glGetLightfv, +glTexGenf, glTexGend, glTexGeni, glMultiTexCoord3s, glVertexAttribI2uiv, +glMultiTexCoord3i, glMultiTexCoord3f, glMultiTexCoord3d, glAttachShader, glFogCoorddv, +glGetTexGenfv, glQueryCounter, glFogCoordPointer, glProvokingVertex, glRasterPos4dv, +glTexGeniv, glDrawElements, glColorMaterial, glSecondaryColor3dv, glClientActiveTexture, +glVertexAttribI4sv, glTexCoord2iv, glUniform1iv, glGetBufferParameteriv, glReadBuffer, +glTexParameterIuiv, glDrawArraysInstanced, glGenerateMipmap, glWindowPos3fv, glLightModelfv, +glSamplerParameteriv, glDeleteLists, glGetClipPlane, glVertexAttrib3f, glTexCoord2d, +glVertexAttrib3d, glTexCoord2f, glRasterPos2dv, glIndexubv, glUnmapBuffer, +glTexCoord2i, glRasterPos4d, glRasterPos4f, glVertexAttrib3s, glTexCoord2s, +glBindRenderbuffer, glVertex3fv, glTexCoord4dv, glMaterialiv, glVertexAttribP4uiv, +glIsProgram, glPointParameterfv, glVertex4s, glPopMatrix, glVertexAttrib4fv, +glNormal3dv, glUniform4i, glActiveTexture, glEnableVertexAttribArray, glRotated, +glRotatef, glVertex4i, glArrayElement, glReadPixels, glVertexAttribI3iv, +glStencilMask, glUniform4f, glRenderbufferStorageMultisample, glColor3d, glGenVertexArrays, +glShadeModel, glMapGrid1d, glGetUniformfv, glMapGrid1f, glDrawPixels, +glDisableClientState, glMultiTexCoord3sv, glDrawElementsInstancedBaseVertex, glSecondaryColorPointer, glAlphaFunc, +glMultiTexCoord4iv, glTexEnvfv, glStencilFunc, glTexCoord3dv, glUniformBlockBinding, +glColor4uiv, glRectiv, glColorP4ui, glRasterPos3dv, glEvalMesh2, +glEvalMesh1, glTexCoordPointer, glLoadMatrixf, glVertexAttribI4iv, glEvalCoord2fv, +glGetShaderInfoLog, glLoadTransposeMatrixd, glLoadTransposeMatrixf, glVertexAttribI4i, glRasterPos2iv, +glGetBufferSubData, glTexEnviv, glBlendEquationSeparate, glVertexAttribI1ui, glGenBuffers, +glSelectBuffer, glTexCoordP1uiv, glPushAttrib, glVertexAttribIPointer, glBlendFunc, +glCreateProgram, glTexImage3D, glIsFramebuffer, glLightiv, glPrimitiveRestartIndex, +glTexGenfv, glTexCoord1dv, glEnd, glGetInteger64v, glScissor, +glTexCoordP4uiv, glGetBooleanv, glPushName, glMaterialfv, glIndexub, +glVertexP2uiv, glUniform3uiv, glMultTransposeMatrixf, glMultTransposeMatrixd, glClearColor, +glVertexAttrib4uiv, glPolygonStipple, glVertexAttrib4Niv, glClearBufferiv, glGetBufferParameteri64v, +glColorP4uiv, glBlendColor, glWindowPos3d, glGetStringi, glColor4iv, +glUniform3ui, glSecondaryColor3us, glVertexAttribI4uiv, glVertexAttrib4bv, glUniform2fv, +glSecondaryColor3ub, glSecondaryColor3ui, glMultiTexCoord1fv, glGetSamplerParameterIuiv, glNormal3i, +glTexCoordP3ui, glNormal3iv, glWindowPos3s, glPointParameterf, glColor3us, +glWindowPos3i, glUniformMatrix2x3fv, glWindowPos3f, glGetVertexAttribIuiv, glMultiTexCoord4s, +glVertexAttrib4Nusv, glGetLightiv, glDepthFunc, glCompressedTexSubImage2D, glListBase, +glMultiTexCoord4f, glColor3ub, glMultiTexCoord4d, glVertexAttribI4bv, glGetTexParameterfv, +glColor3ui, glMultiTexCoord4i, glGetPolygonStipple, glClientWaitSync, glVertexAttribI4ui, +glPixelMapusv, glColorMask, glTexParameterIiv, glBlendEquation, glGetUniformLocation, +glGetTexGeniv, glRasterPos4s, glEndTransformFeedback, glVertexAttrib4usv, glTexImage2DMultisample, +glColor4sv, glPopClientAttrib, glColor4dv, glBeginTransformFeedback, glFogf, +glVertexAttribI1iv, glIsSampler, glVertexP3ui, glVertexAttribDivisor, glColor3iv, +glCompressedTexImage1D, glCopyTexSubImage1D, glDrawRangeElementsBaseVertex, glCheckFramebufferStatus, glTexCoord1d, +glTexCoord1f, glEndConditionalRender, glUniform1uiv, glBindAttribLocation, glUniformMatrix4x2fv, +glMultiTexCoord2sv, glVertexAttrib1dv, glDrawRangeElements, glGetQueryObjectuiv, glSamplerParameterIiv, +glBufferSubData, glVertexAttribI2i, glGenLists, glColor3bv, glMapBufferRange, +glFramebufferTexture, glGetTexGendv, glMultiDrawArrays, glEndList, glVertexP4uiv, +glUniform2ui, glVertexAttribI2iv, glColor3usv, glWindowPos2fv, glDisablei, +glIndexMask, glPushClientAttrib, glVertex4dv, glTexCoordP4ui, glGetActiveUniformBlockName, +glVertexAttribI3uiv, glClearAccum, glGetSynciv, glTexCoordP2uiv, glUniform2f, +glBeginQuery, glUniformMatrix4fv, glBindBuffer, glMap2d, glMap2f, +glRasterPos2sv, glUniformMatrix2fv, glUniformMatrix2x4fv, glBufferData, glEvalPoint1, +glGetTexParameterIiv, glIsEnabled, glTexCoordP1ui, glGetError, glGetTexEnviv, +glGetProgramiv, glVertexAttribP2ui, glNewList, glSecondaryColor3i, glMultiTexCoord2fv, +glNormalP3ui, glEvalCoord1d, glGetTexLevelParameterfv, glEvalCoord1f, glVertexAttribI1i, +glVertex4d, glVertexAttribP3uiv, glGetPixelMapusv, glSecondaryColorP3uiv, glGetIntegerv, +glAccum, glGetBufferPointerv, glGetVertexAttribIiv, glFramebufferTexture3D, glVertexAttrib2fv, +glIsQuery, glVertexAttrib4sv, glWindowPos3dv, glTexImage2D, glLoadName, +glSamplerParameterfv, glMultMatrixd, glMultMatrixf, glIsTexture, glGetMaterialiv, +glUniform1fv, glVertexAttrib4Nubv, glLoadMatrixd, glTexParameterfv, glUniformMatrix3fv, +glVertex4f, glRectsv, glColor4usv, glNormal3s, glInterleavedArrays, +glHint, glNormal3f, glNormal3d, glNormal3b, glMultiTexCoord4dv, +glGetSamplerParameteriv, glPopName, glCopyBufferSubData, glVertexAttribI1uiv, glVertexAttrib2d, +glVertexAttrib2f, glVertexAttrib3dv, glGetQueryObjectui64v, glDepthMask, glVertexAttrib2s, +glColor3fv, glTexImage3DMultisample, glGetUniformBlockIndex, glMultiTexCoord3dv, glGetActiveUniform, +glColorPointer, glFrontFace, glGetBooleani_v, glClearBufferuiv; + +public import glad.gl.enums : +GL_INDEX_CLEAR_VALUE, GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, GL_FOG_INDEX, GL_ALPHA_TEST_FUNC, +GL_SOURCE1_ALPHA, GL_NORMAL_MAP, GL_DITHER, GL_QUERY_RESULT, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, +GL_R16_SNORM, GL_FOG_COORD_ARRAY, GL_FLOAT, GL_PROXY_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LOD, +GL_RGB16_SNORM, GL_SAMPLER_2D_RECT, GL_RGB9_E5, GL_MAX_VERTEX_UNIFORM_BLOCKS, GL_TEXTURE_COMPRESSED, +GL_T2F_C4UB_V3F, GL_EDGE_FLAG_ARRAY_POINTER, GL_PROXY_TEXTURE_3D, GL_MAX_LIST_NESTING, GL_COLOR_ATTACHMENT22, +GL_SOURCE0_ALPHA, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_BYTE, GL_TIMEOUT_IGNORED, +GL_COLOR_ARRAY, GL_ZOOM_Y, GL_ZOOM_X, GL_RENDERBUFFER_SAMPLES, GL_HINT_BIT, +GL_COLOR_CLEAR_VALUE, GL_LINEAR_MIPMAP_LINEAR, GL_DEPTH_WRITEMASK, GL_TEXTURE_GEN_MODE, GL_3D_COLOR_TEXTURE, +GL_COLOR_ARRAY_POINTER, GL_TEXTURE_DEPTH_SIZE, GL_FLOAT_MAT3x2, GL_PIXEL_MAP_G_TO_G, GL_RENDER, +GL_MAX_TEXTURE_COORDS, GL_FLOAT_MAT3x4, GL_COLOR_ATTACHMENT28, GL_TEXTURE_BINDING_2D_MULTISAMPLE, GL_COLOR_ATTACHMENT24, +GL_COLOR_ATTACHMENT25, GL_COLOR_ATTACHMENT26, GL_COLOR_ATTACHMENT27, GL_COLOR_ATTACHMENT20, GL_COLOR_ATTACHMENT21, +GL_COMPRESSED_RGBA, GL_COLOR_ATTACHMENT23, GL_CLIENT_ATTRIB_STACK_DEPTH, GL_UNSIGNED_SHORT_5_5_5_1, GL_TEXTURE_COMPONENTS, +GL_QUERY_NO_WAIT, GL_PROVOKING_VERTEX, GL_SIGNED_NORMALIZED, GL_CURRENT_RASTER_TEXTURE_COORDS, GL_EXP, +GL_LINE_STRIP_ADJACENCY, GL_POINT_SIZE, GL_TEXTURE_COMPARE_FUNC, GL_TRANSFORM_FEEDBACK_BUFFER_MODE, GL_BITMAP_TOKEN, +GL_RGB10, GL_RGB16, GL_POLYGON_OFFSET_FILL, GL_LINE_TOKEN, GL_DOUBLEBUFFER, +GL_MAX_CLIP_PLANES, GL_FOG_COORDINATE_ARRAY_STRIDE, GL_RGB_INTEGER, GL_COMPILE_AND_EXECUTE, GL_MULT, +GL_STENCIL_CLEAR_VALUE, GL_GREEN_BITS, GL_SHADING_LANGUAGE_VERSION, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_SRC2_RGB, +GL_FRAGMENT_SHADER, GL_UNSIGNED_INT_2_10_10_10_REV, GL_INDEX_ARRAY_TYPE, GL_FRAGMENT_SHADER_DERIVATIVE_HINT, GL_TEXTURE_DEPTH, +GL_VIEWPORT, GL_DRAW_BUFFER6, GL_DRAW_BUFFER7, GL_DRAW_BUFFER4, GL_DRAW_BUFFER5, +GL_DRAW_BUFFER2, GL_DRAW_BUFFER3, GL_DRAW_BUFFER0, GL_DRAW_BUFFER1, GL_LIGHT1, +GL_LIGHT0, GL_LIGHT3, GL_LIGHT2, GL_COPY, GL_LIGHT4, +GL_BLEND_SRC, GL_LIGHT6, GL_MAP_STENCIL, GL_QUADRATIC_ATTENUATION, GL_TEXTURE_CUBE_MAP_SEAMLESS, +GL_TEXTURE_RECTANGLE, GL_FILL, GL_SRC_COLOR, GL_SAMPLER_BINDING, GL_DEPTH24_STENCIL8, +GL_SAMPLE_BUFFERS, GL_RGBA_INTEGER, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_COLOR_INDEX, GL_EXTENSIONS, +GL_MAP2_NORMAL, GL_BUFFER_SIZE, GL_PASS_THROUGH_TOKEN, GL_MAX_EVAL_ORDER, GL_UPPER_LEFT, +GL_TEXTURE_COMPARE_MODE, GL_ANY_SAMPLES_PASSED, GL_LAST_VERTEX_CONVENTION, GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, GL_DEPTH_BUFFER_BIT, +GL_STENCIL_BACK_PASS_DEPTH_FAIL, GL_UNSIGNALED, GL_UNIFORM_BUFFER, GL_MAP_WRITE_BIT, GL_SHADE_MODEL, +GL_COMPRESSED_SLUMINANCE, GL_CCW, GL_RGB32I, GL_DEPTH_COMPONENT24, GL_INDEX_SHIFT, +GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_LIST_BIT, GL_ONE_MINUS_SRC1_COLOR, GL_STREAM_READ, GL_LINEAR, +GL_R32F, GL_VERTEX_ARRAY, GL_OR_REVERSE, GL_LUMINANCE12_ALPHA4, GL_LOGIC_OP, +GL_VERTEX_ARRAY_BUFFER_BINDING, GL_PIXEL_MAP_R_TO_R, GL_FOG_COORDINATE_SOURCE, GL_UNSIGNED_SHORT_5_6_5_REV, GL_TEXTURE_BORDER, +GL_GREATER, GL_MAX_GEOMETRY_UNIFORM_COMPONENTS, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_MAX_TEXTURE_IMAGE_UNITS, GL_RGB32F, +GL_FLOAT_MAT2, GL_FLOAT_MAT3, GL_FRONT_FACE, GL_DEPTH, GL_REPLACE, +GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, GL_OPERAND1_RGB, GL_RGBA32UI, GL_RG8I, +GL_RGBA8I, GL_TEXTURE_FILTER_CONTROL, GL_ACCUM_CLEAR_VALUE, GL_SRC1_ALPHA, GL_RG32F, +GL_R3_G3_B2, GL_ALPHA_BIAS, GL_RENDERBUFFER_BINDING, GL_TEXTURE_STACK_DEPTH, GL_TEXTURE_LUMINANCE_SIZE, +GL_TEXTURE_MIN_LOD, GL_FOG_COORDINATE_ARRAY, GL_BLEND, GL_FEEDBACK_BUFFER_TYPE, GL_MAP1_TEXTURE_COORD_3, +GL_R16UI, GL_MAP1_TEXTURE_COORD_1, GL_UNSIGNED_SHORT, GL_MIN, GL_MAP1_TEXTURE_COORD_4, +GL_COMPRESSED_SRGB_ALPHA, GL_ONE_MINUS_SRC_COLOR, GL_TEXTURE, GL_INTENSITY12, GL_MAX_PROJECTION_STACK_DEPTH, +GL_RGB_SCALE, GL_MAX_CLIP_DISTANCES, GL_PERSPECTIVE_CORRECTION_HINT, GL_LIST_MODE, GL_TIMESTAMP, +GL_ACTIVE_UNIFORMS, GL_VERTEX_PROGRAM_POINT_SIZE, GL_MAX_COLOR_ATTACHMENTS, GL_TEXTURE_BINDING_CUBE_MAP, GL_OPERAND2_RGB, +GL_R, GL_SRGB_ALPHA, GL_S, GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_PACK_SKIP_ROWS, +GL_T, GL_MAX_TEXTURE_UNITS, GL_SLUMINANCE8, GL_MAX_TEXTURE_BUFFER_SIZE, GL_MAP1_COLOR_4, +GL_GEOMETRY_SHADER, GL_R8I, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_BLEND_COLOR, +GL_ALPHA_BITS, GL_LINE_STIPPLE, GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, GL_ONE_MINUS_CONSTANT_ALPHA, GL_NEAREST_MIPMAP_LINEAR, +GL_ALPHA8, GL_BLEND_EQUATION, GL_SRC2_ALPHA, GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER, GL_ALPHA4, +GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, GL_FOG_END, GL_SAMPLER_1D, GL_LINE, GL_STENCIL_BITS, +GL_FOG_COORDINATE_ARRAY_TYPE, GL_SAMPLES_PASSED, GL_RENDERBUFFER_RED_SIZE, GL_COMPRESSED_SLUMINANCE_ALPHA, GL_BLUE_INTEGER, +GL_DYNAMIC_COPY, GL_CURRENT_FOG_COORD, GL_SYNC_FLAGS, GL_RG32I, GL_UNSIGNED_BYTE_2_3_3_REV, +GL_RENDERBUFFER_INTERNAL_FORMAT, GL_CLIENT_ACTIVE_TEXTURE, GL_TEXTURE_HEIGHT, GL_RGBA16I, GL_RGBA16F, +GL_OPERAND2_ALPHA, GL_SAMPLE_ALPHA_TO_COVERAGE, GL_FOG_DENSITY, GL_TEXTURE_FIXED_SAMPLE_LOCATIONS, GL_CONSTANT_ATTENUATION, +GL_RED, GL_DEPTH_BIAS, GL_EQUIV, GL_POLYGON_OFFSET_LINE, GL_FUNC_REVERSE_SUBTRACT, +GL_GREEN, GL_INVALID_OPERATION, GL_CLAMP_READ_COLOR, GL_RED_INTEGER, GL_TEXTURE_BINDING_BUFFER, +GL_COLOR_ATTACHMENT5, GL_COLOR_ATTACHMENT4, GL_MAP2_TEXTURE_COORD_2, GL_COLOR_ATTACHMENT6, GL_MAP2_TEXTURE_COORD_4, +GL_COLOR_ATTACHMENT0, GL_4_BYTES, GL_COLOR_ATTACHMENT2, GL_MAX_MODELVIEW_STACK_DEPTH, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, +GL_COLOR_ATTACHMENT9, GL_COLOR_ATTACHMENT8, GL_PACK_IMAGE_HEIGHT, GL_PIXEL_MAP_B_TO_B_SIZE, GL_BUFFER_USAGE, +GL_CULL_FACE_MODE, GL_UNSIGNED_INT_8_8_8_8_REV, GL_BOOL, GL_MAX_COMBINED_UNIFORM_BLOCKS, GL_3D_COLOR, +GL_GREEN_INTEGER, GL_DST_COLOR, GL_T2F_V3F, GL_UNSIGNED_INT, GL_OPERAND0_ALPHA, +GL_ALWAYS, GL_NOOP, GL_V3F, GL_POINT_SPRITE_COORD_ORIGIN, GL_POINT_SIZE_RANGE, +GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, GL_LUMINANCE16, GL_GREEN_BIAS, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, GL_LUMINANCE12, +GL_SAMPLER_2D_MULTISAMPLE_ARRAY, GL_SHADER_TYPE, GL_RG16_SNORM, GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, GL_COLOR_ARRAY_TYPE, +GL_QUERY_COUNTER_BITS, GL_MODULATE, GL_RG_INTEGER, GL_DRAW_BUFFER10, GL_FOG_COORD_ARRAY_BUFFER_BINDING, +GL_TEXTURE_LUMINANCE_TYPE, GL_RENDERBUFFER_HEIGHT, GL_RG16UI, GL_INTERLEAVED_ATTRIBS, GL_TEXTURE_ALPHA_TYPE, +GL_COLOR_ATTACHMENT29, GL_MAP2_TEXTURE_COORD_1, GL_DRAW_BUFFER14, GL_FOG_COORD_ARRAY_STRIDE, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, +GL_MAP2_TEXTURE_COORD_3, GL_TEXTURE_BLUE_TYPE, GL_COLOR_ATTACHMENT1, GL_C4F_N3F_V3F, GL_COMBINE_RGB, +GL_STEREO, GL_ALREADY_SIGNALED, GL_T4F_V4F, GL_STREAM_COPY, GL_LIGHT_MODEL_LOCAL_VIEWER, +GL_SOURCE0_RGB, GL_EYE_PLANE, GL_TEXTURE_CUBE_MAP, GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_2D_MULTISAMPLE_ARRAY, +GL_CLIP_PLANE1, GL_CLIP_PLANE0, GL_CLIP_PLANE3, GL_CLIP_PLANE2, GL_CLIP_PLANE5, +GL_CLIP_PLANE4, GL_ORDER, GL_NORMAL_ARRAY_TYPE, GL_TEXTURE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER, +GL_LINE_STIPPLE_REPEAT, GL_POINTS, GL_LIGHTING_BIT, GL_SYNC_STATUS, GL_RENDERBUFFER_BLUE_SIZE, +GL_UNIFORM_NAME_LENGTH, GL_FASTEST, GL_LUMINANCE8, GL_LUMINANCE4, GL_POLYGON, +GL_NAND, GL_MAP1_INDEX, GL_LINE_WIDTH_GRANULARITY, GL_ADD_SIGNED, GL_MAX_3D_TEXTURE_SIZE, +GL_CLIENT_PIXEL_STORE_BIT, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_DONT_CARE, +GL_POLYGON_BIT, GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING, GL_QUERY_WAIT, GL_MAP_FLUSH_EXPLICIT_BIT, GL_TEXTURE_COORD_ARRAY_SIZE, +GL_RED_SCALE, GL_SRGB8, GL_CURRENT_NORMAL, GL_COMPRESSED_SIGNED_RED_RGTC1, GL_FRAGMENT_DEPTH, +GL_UNIFORM_BLOCK_BINDING, GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, GL_SRC0_ALPHA, GL_LEQUAL, GL_PIXEL_MAP_A_TO_A_SIZE, +GL_TEXTURE_WIDTH, GL_ONE_MINUS_SRC1_ALPHA, GL_MAP_COLOR, GL_UNIFORM_SIZE, GL_POINT_SPRITE, +GL_FLOAT_MAT4x2, GL_SHADER_SOURCE_LENGTH, GL_DOT3_RGBA, GL_COMPRESSED_RG, GL_UNPACK_SWAP_BYTES, +GL_CURRENT_VERTEX_ATTRIB, GL_POLYGON_OFFSET_UNITS, GL_LUMINANCE6_ALPHA2, GL_MAX_COLOR_TEXTURE_SAMPLES, GL_COLOR_ATTACHMENT7, +GL_PRIMARY_COLOR, GL_C3F_V3F, GL_OUT_OF_MEMORY, GL_AUX_BUFFERS, GL_NORMAL_ARRAY_STRIDE, +GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_SMOOTH, GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, GL_GEOMETRY_OUTPUT_TYPE, GL_RASTERIZER_DISCARD, +GL_MAX_TEXTURE_LOD_BIAS, GL_CURRENT_TEXTURE_COORDS, GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE, GL_FRONT_RIGHT, +GL_EDGE_FLAG_ARRAY, GL_INT_SAMPLER_2D_MULTISAMPLE, GL_RETURN, GL_STENCIL_TEST, GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION, +GL_R11F_G11F_B10F, GL_LUMINANCE_ALPHA, GL_PIXEL_UNPACK_BUFFER_BINDING, GL_INVERT, GL_PROXY_TEXTURE_1D, +GL_COMPRESSED_INTENSITY, GL_TRANSFORM_FEEDBACK_VARYINGS, GL_DEPTH_COMPONENT32F, GL_TRIANGLE_FAN, GL_LIST_BASE, +GL_MAX_ELEMENTS_VERTICES, GL_CURRENT_COLOR, GL_INVALID_FRAMEBUFFER_OPERATION, GL_RGB12, GL_UNIFORM_BUFFER_SIZE, +GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING, GL_DEPTH32F_STENCIL8, GL_MAX_ARRAY_TEXTURE_LAYERS, GL_RED_BITS, GL_MAX_SERVER_WAIT_TIMEOUT, +GL_NOR, GL_FLAT, GL_PACK_ALIGNMENT, GL_PIXEL_MAP_S_TO_S, GL_UNPACK_LSB_FIRST, +GL_BGRA, GL_ACTIVE_UNIFORM_BLOCKS, GL_SOURCE1_RGB, GL_UNPACK_SKIP_IMAGES, GL_RGB16I, +GL_ACTIVE_TEXTURE, GL_TEXTURE_BASE_LEVEL, GL_RGB16F, GL_SMOOTH_LINE_WIDTH_RANGE, GL_ALPHA_INTEGER, +GL_GREEN_SCALE, GL_CLIP_DISTANCE7, GL_FOG_BIT, GL_TRANSPOSE_TEXTURE_MATRIX, GL_UNSIGNED_INT_SAMPLER_3D, +GL_SAMPLE_MASK, GL_INT_VEC4, GL_INT_VEC3, GL_INT_VEC2, GL_STENCIL_FAIL, +GL_CURRENT_FOG_COORDINATE, GL_CONDITION_SATISFIED, GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT, GL_FRAMEBUFFER_UNSUPPORTED, GL_RED_BIAS, +GL_DST_ALPHA, GL_SECONDARY_COLOR_ARRAY_POINTER, GL_R8, GL_RENDER_MODE, GL_EDGE_FLAG_ARRAY_BUFFER_BINDING, +GL_MAX_CUBE_MAP_TEXTURE_SIZE, GL_TEXTURE_1D_ARRAY, GL_RENDERBUFFER_WIDTH, GL_READ_FRAMEBUFFER_BINDING, GL_FRAMEBUFFER_ATTACHMENT_LAYERED, +GL_TEXTURE_BLUE_SIZE, GL_COORD_REPLACE, GL_RGBA2, GL_RGBA4, GL_MULTISAMPLE_BIT, +GL_FOG_COLOR, GL_DRAW_BUFFER11, GL_DRAW_BUFFER12, GL_DRAW_BUFFER13, GL_UNSIGNED_INT_10_10_10_2, +GL_DRAW_BUFFER15, GL_INFO_LOG_LENGTH, GL_R16F, GL_RENDERBUFFER_STENCIL_SIZE, GL_CONSTANT_ALPHA, +GL_RESCALE_NORMAL, GL_R16I, GL_POINT_SIZE_GRANULARITY, GL_STATIC_READ, GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, +GL_COMPARE_R_TO_TEXTURE, GL_PREVIOUS, GL_MAP_READ_BIT, GL_SPOT_DIRECTION, GL_DEPTH_SCALE, +GL_STENCIL, GL_SAMPLE_MASK_VALUE, GL_LINE_BIT, GL_DIFFUSE, GL_MAX_RENDERBUFFER_SIZE, +GL_T2F_N3F_V3F, GL_TRANSFORM_BIT, GL_COLOR_ATTACHMENT30, GL_STENCIL_PASS_DEPTH_PASS, GL_INCR_WRAP, +GL_SOURCE2_RGB, GL_TEXTURE_GEN_T, GL_TEXTURE_GEN_S, GL_TEXTURE_GEN_R, GL_TEXTURE_GEN_Q, +GL_RENDERBUFFER_ALPHA_SIZE, GL_ALPHA12, GL_LIGHT_MODEL_TWO_SIDE, GL_ALPHA16, GL_DECR_WRAP, +GL_POLYGON_SMOOTH, GL_COMPILE, GL_SAMPLE_POSITION, GL_TRANSPOSE_MODELVIEW_MATRIX, GL_INCR, +GL_POINT_SIZE_MIN, GL_MAX_RECTANGLE_TEXTURE_SIZE, GL_RGBA12, GL_GENERATE_MIPMAP_HINT, GL_ALPHA_TEST_REF, +GL_RGBA16, GL_UNPACK_SKIP_ROWS, GL_MAP1_NORMAL, GL_SOURCE2_ALPHA, GL_DEPTH_CLAMP, +GL_POLYGON_STIPPLE_BIT, GL_BLEND_DST_ALPHA, GL_INT_SAMPLER_CUBE, GL_CURRENT_QUERY, GL_RGB5_A1, +GL_EXP2, GL_UNPACK_SKIP_PIXELS, GL_RGB16UI, GL_COPY_INVERTED, GL_TEXTURE_PRIORITY, +GL_MAX_GEOMETRY_INPUT_COMPONENTS, GL_LOWER_LEFT, GL_FOG_HINT, GL_TEXTURE_BINDING_1D, GL_PROJECTION_MATRIX, +GL_AUX0, GL_PIXEL_UNPACK_BUFFER, GL_LINEAR_MIPMAP_NEAREST, GL_POINT_DISTANCE_ATTENUATION, GL_TEXTURE_BUFFER_DATA_STORE_BINDING, +GL_RGB10_A2, GL_AMBIENT_AND_DIFFUSE, GL_ZERO, GL_ELEMENT_ARRAY_BUFFER, GL_CONTEXT_CORE_PROFILE_BIT, +GL_SCISSOR_BIT, GL_READ_ONLY, GL_MAX_FRAGMENT_INPUT_COMPONENTS, GL_MAP1_GRID_DOMAIN, GL_PIXEL_MAP_I_TO_A_SIZE, +GL_UNSIGNED_NORMALIZED, GL_SMOOTH_POINT_SIZE_GRANULARITY, GL_CLAMP_VERTEX_COLOR, GL_MAP2_INDEX, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, +GL_PIXEL_MAP_I_TO_R_SIZE, GL_NOTEQUAL, GL_TEXTURE_COORD_ARRAY, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GL_MAP2_GRID_DOMAIN, +GL_COMPRESSED_RED, GL_INT_SAMPLER_1D_ARRAY, GL_DRAW_PIXEL_TOKEN, GL_MAX_LIGHTS, GL_RGBA16_SNORM, +GL_OBJECT_LINEAR, GL_LIST_INDEX, GL_TEXTURE_BORDER_COLOR, GL_LUMINANCE16_ALPHA16, GL_TEXTURE_SHARED_SIZE, +GL_COMPILE_STATUS, GL_LOGIC_OP_MODE, GL_LUMINANCE8_ALPHA8, GL_RENDERBUFFER_DEPTH_SIZE, GL_MAX_FRAGMENT_UNIFORM_BLOCKS, +GL_SLUMINANCE_ALPHA, GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, GL_FEEDBACK_BUFFER_POINTER, GL_SPOT_EXPONENT, GL_SHORT, +GL_BLUE, GL_CW, GL_UNSIGNED_INT_24_8, GL_UNSIGNED_BYTE, GL_MAX_VERTEX_UNIFORM_COMPONENTS, +GL_QUADS, GL_DEPTH_TEXTURE_MODE, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_R16, GL_PIXEL_PACK_BUFFER, +GL_PACK_LSB_FIRST, GL_RENDERBUFFER, GL_UNSIGNED_BYTE_3_3_2, GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, GL_RGB8I, +GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, GL_DRAW_BUFFER, GL_STENCIL_INDEX1, GL_STENCIL_INDEX4, GL_SAMPLER_3D, +GL_TEXTURE_GREEN_TYPE, GL_STENCIL_INDEX8, GL_DEPTH_BITS, GL_OR_INVERTED, GL_RGB8UI, +GL_STENCIL_INDEX16, GL_STENCIL_BACK_REF, GL_SELECT, GL_INTENSITY4, GL_BLEND_DST_RGB, +GL_INTENSITY8, GL_LIGHT5, GL_LINE_RESET_TOKEN, GL_MAP1_VERTEX_3, GL_TEXTURE_BINDING_2D_ARRAY, +GL_VERTEX_ATTRIB_ARRAY_DIVISOR, GL_CLEAR, GL_DRAW_BUFFER8, GL_CURRENT_RASTER_POSITION_VALID, GL_FOG_COORD_SRC, +GL_DRAW_BUFFER9, GL_SRC0_RGB, GL_PIXEL_PACK_BUFFER_BINDING, GL_DECAL, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, +GL_2D, GL_SELECTION_BUFFER_POINTER, GL_SELECTION_BUFFER_SIZE, GL_SAMPLES, GL_UNSIGNED_INT_VEC2, +GL_UNSIGNED_INT_VEC3, GL_UNSIGNED_INT_VEC4, GL_UNSIGNED_SHORT_5_6_5, GL_CURRENT_RASTER_POSITION, GL_VERTEX_ATTRIB_ARRAY_SIZE, +GL_VERTEX_SHADER, GL_RGBA_MODE, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4, +GL_COEFF, GL_RGB32UI, GL_BUFFER_MAP_OFFSET, GL_MIN_PROGRAM_TEXEL_OFFSET, GL_PROXY_TEXTURE_RECTANGLE, +GL_UNSIGNED_INT_SAMPLER_BUFFER, GL_UNIFORM_BUFFER_START, GL_MAX_TEXTURE_STACK_DEPTH, GL_UNSIGNED_INT_SAMPLER_2D, GL_TEXTURE8, +GL_INT_SAMPLER_2D_RECT, GL_TEXTURE_COORD_ARRAY_STRIDE, GL_TEXTURE4, GL_TEXTURE5, GL_TEXTURE6, +GL_TEXTURE7, GL_TEXTURE0, GL_CONTEXT_PROFILE_MASK, GL_TEXTURE2, GL_TEXTURE3, +GL_BOOL_VEC4, GL_DOUBLE, GL_RG8_SNORM, GL_BOOL_VEC3, GL_BOOL_VEC2, +GL_COLOR_MATERIAL_PARAMETER, GL_DOT3_RGB, GL_ONE, GL_SRC_ALPHA_SATURATE, GL_MAX_SAMPLES, +GL_UNPACK_IMAGE_HEIGHT, GL_TRIANGLE_STRIP, GL_N3F_V3F, GL_CONTEXT_FLAGS, GL_FRONT_LEFT, +GL_CLAMP, GL_POINT_SMOOTH_HINT, GL_INDEX_OFFSET, GL_INTENSITY, GL_POINT_SIZE_MAX, +GL_MODELVIEW_MATRIX, GL_VERTEX_ARRAY_BINDING, GL_INDEX_BITS, GL_TIMEOUT_EXPIRED, GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, +GL_STENCIL_FUNC, GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING, GL_TEXTURE_ENV, GL_ALIASED_LINE_WIDTH_RANGE, GL_DECR, +GL_BACK, GL_VIEWPORT_BIT, GL_INT, GL_CLIP_DISTANCE1, GL_CLIP_DISTANCE0, +GL_CLIP_DISTANCE3, GL_CLIP_DISTANCE2, GL_CLIP_DISTANCE5, GL_CLIP_DISTANCE4, GL_MINOR_VERSION, +GL_PIXEL_MAP_G_TO_G_SIZE, GL_FRONT_AND_BACK, GL_POINT, GL_COMPRESSED_RG_RGTC2, GL_POLYGON_TOKEN, +GL_SMOOTH_LINE_WIDTH_GRANULARITY, GL_SRGB, GL_NORMAL_ARRAY_POINTER, GL_SYNC_FENCE, GL_ONE_MINUS_CONSTANT_COLOR, +GL_UNSIGNED_INT_8_8_8_8, GL_RGB8_SNORM, GL_TEXTURE_ALPHA_SIZE, GL_UNSIGNED_INT_SAMPLER_2D_RECT, GL_CONSTANT_COLOR, +GL_UNSIGNED_SHORT_4_4_4_4, GL_NO_ERROR, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, GL_BLEND_SRC_ALPHA, GL_CURRENT_SECONDARY_COLOR, +GL_RGBA16UI, GL_AND_REVERSE, GL_MAX_INTEGER_SAMPLES, GL_CLAMP_FRAGMENT_COLOR, GL_QUERY_RESULT_AVAILABLE, +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, GL_MAX_DRAW_BUFFERS, GL_ONE_MINUS_DST_ALPHA, GL_FOG_MODE, GL_R32UI, +GL_RGBA8_SNORM, GL_C4UB_V2F, GL_INT_SAMPLER_3D, GL_CURRENT_INDEX, GL_AND, +GL_INDEX_MODE, GL_ACCUM_GREEN_BITS, GL_MAJOR_VERSION, GL_STATIC_COPY, GL_REFLECTION_MAP, +GL_BGR_INTEGER, GL_3_BYTES, GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_TYPE, GL_DELETE_STATUS, +GL_POINT_BIT, GL_SYNC_GPU_COMMANDS_COMPLETE, GL_SMOOTH_POINT_SIZE_RANGE, GL_ALIASED_POINT_SIZE_RANGE, GL_3D, +GL_MAP_INVALIDATE_BUFFER_BIT, GL_UNSIGNED_INT_5_9_9_9_REV, GL_DEPTH_TEST, GL_BUFFER_MAP_LENGTH, GL_VERTEX_ATTRIB_ARRAY_POINTER, +GL_MULTISAMPLE, GL_MAX_GEOMETRY_OUTPUT_VERTICES, GL_TEXTURE_RED_TYPE, GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_FUNC_SUBTRACT, +GL_VERTEX_PROGRAM_TWO_SIDE, GL_SAMPLER_BUFFER, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, GL_TEXTURE_COORD_ARRAY_TYPE, GL_CLAMP_TO_BORDER, +GL_COLOR_ATTACHMENT15, GL_COLOR_ATTACHMENT14, GL_COLOR_ATTACHMENT17, GL_DEPTH_RANGE, GL_COLOR_ATTACHMENT11, +GL_COLOR_ATTACHMENT10, GL_COLOR_ATTACHMENT13, GL_COLOR_ATTACHMENT12, GL_NEAREST, GL_COMPRESSED_TEXTURE_FORMATS, +GL_COLOR_ATTACHMENT19, GL_COLOR_ATTACHMENT18, GL_RENDERBUFFER_GREEN_SIZE, GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, GL_PIXEL_MAP_S_TO_S_SIZE, +GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, GL_RGBA8, GL_T2F_C3F_V3F, GL_SAMPLER_2D_RECT_SHADOW, GL_ALL_ATTRIB_BITS, +GL_POINT_TOKEN, GL_T4F_C4F_N3F_V4F, GL_TEXTURE30, GL_TEXTURE31, GL_UNSIGNED_INT_SAMPLER_1D, +GL_POINT_SMOOTH, GL_DEPTH_CLEAR_VALUE, GL_GEOMETRY_INPUT_TYPE, GL_BACK_LEFT, GL_TEXTURE_ENV_COLOR, +GL_BUFFER_MAP_POINTER, GL_LINE_SMOOTH, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, GL_STENCIL_REF, GL_CURRENT_BIT, +GL_FOG_COORDINATE, GL_COPY_WRITE_BUFFER, GL_MAX_VARYING_FLOATS, GL_PRIMITIVE_RESTART_INDEX, GL_OPERAND0_RGB, +GL_LIGHT_MODEL_COLOR_CONTROL, GL_FEEDBACK, GL_ONE_MINUS_DST_COLOR, GL_MAX_ATTRIB_STACK_DEPTH, GL_FOG_COORD_ARRAY_TYPE, +GL_PROXY_TEXTURE_1D_ARRAY, GL_ACCUM_ALPHA_BITS, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, GL_PIXEL_MAP_I_TO_A, +GL_COLOR_BUFFER_BIT, GL_PIXEL_MAP_I_TO_I, GL_SPOT_CUTOFF, GL_PIXEL_MAP_I_TO_R, GL_LINEAR_ATTENUATION, +GL_SAMPLER_2D, GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, GL_NEAREST_MIPMAP_NEAREST, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER, GL_EDGE_FLAG_ARRAY_STRIDE, +GL_TEXTURE_MAG_FILTER, GL_COLOR_MATERIAL_FACE, GL_CONTEXT_COMPATIBILITY_PROFILE_BIT, GL_SINGLE_COLOR, GL_R32I, +GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, GL_SAMPLER_CUBE, GL_INT_2_10_10_10_REV, GL_SAMPLER_CUBE_SHADOW, GL_LEFT, +GL_AND_INVERTED, GL_ACCUM_BLUE_BITS, GL_FRAMEBUFFER_SRGB, GL_SECONDARY_COLOR_ARRAY_TYPE, GL_POLYGON_OFFSET_POINT, +GL_BGR, GL_MAX_TEXTURE_SIZE, GL_COMBINE_ALPHA, GL_RIGHT, GL_UNSIGNED_INT_SAMPLER_2D_ARRAY, +GL_ARRAY_BUFFER, GL_COMPRESSED_ALPHA, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT16, GL_MAX_SAMPLE_MASK_WORDS, +GL_TEXTURE_COMPRESSED_IMAGE_SIZE, GL_TEXTURE_RED_SIZE, GL_TEXTURE_1D, GL_MAX_VARYING_COMPONENTS, GL_NAME_STACK_DEPTH, +GL_BLEND_SRC_RGB, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, GL_BGRA_INTEGER, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, GL_FALSE, +GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, GL_ONE_MINUS_SRC_ALPHA, GL_SAMPLE_ALPHA_TO_ONE, GL_WEIGHT_ARRAY_BUFFER_BINDING, GL_COLOR_ATTACHMENT3, +GL_PIXEL_MAP_I_TO_G_SIZE, GL_MAP2_GRID_SEGMENTS, GL_PROGRAM_POINT_SIZE, GL_COLOR_ATTACHMENT16, GL_MAX_VIEWPORT_DIMS, +GL_DEPTH_ATTACHMENT, GL_INT_SAMPLER_2D, GL_UNSIGNED_INT_SAMPLER_1D_ARRAY, GL_STENCIL_PASS_DEPTH_FAIL, GL_PIXEL_MAP_A_TO_A, +GL_TEXTURE_COORD_ARRAY_POINTER, GL_MAP1_GRID_SEGMENTS, GL_MAX_GEOMETRY_UNIFORM_BLOCKS, GL_ATTRIB_STACK_DEPTH, GL_LINE_WIDTH, +GL_FEEDBACK_BUFFER_SIZE, GL_BLUE_BIAS, GL_FIXED_ONLY, GL_NONE, GL_FRAMEBUFFER_DEFAULT, +GL_POLYGON_MODE, GL_HALF_FLOAT, GL_UNIFORM_BLOCK_NAME_LENGTH, GL_V2F, GL_TEXTURE_BINDING_RECTANGLE, +GL_LINE_SMOOTH_HINT, GL_CLAMP_TO_EDGE, GL_FRONT, GL_SCISSOR_BOX, GL_UNIFORM_BLOCK_DATA_SIZE, +GL_AMBIENT, GL_NUM_EXTENSIONS, GL_UNIFORM_IS_ROW_MAJOR, GL_MAX_UNIFORM_BLOCK_SIZE, GL_INDEX_ARRAY, +GL_FRAMEBUFFER_BINDING, GL_NORMAL_ARRAY_BUFFER_BINDING, GL_ALPHA, GL_SET, GL_COLOR_WRITEMASK, +GL_DEPTH_FUNC, GL_TEXTURE_WRAP_R, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_TEXTURE9, +GL_INVALID_ENUM, GL_EVAL_BIT, GL_INT_SAMPLER_2D_ARRAY, GL_COMPRESSED_RGB, GL_LIGHT_MODEL_AMBIENT, +GL_DEPTH_COMPONENT, GL_SRC1_COLOR, GL_FOG_START, GL_WAIT_FAILED, GL_COMPARE_REF_TO_TEXTURE, +GL_PROJECTION_STACK_DEPTH, GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, GL_TRUE, GL_TEXTURE_MIN_FILTER, GL_FLOAT_MAT4, +GL_BLUE_BITS, GL_STACK_UNDERFLOW, GL_AUX1, GL_TEXTURE_SWIZZLE_R, GL_AUX3, +GL_AUX2, GL_PACK_SWAP_BYTES, GL_FIRST_VERTEX_CONVENTION, GL_EQUAL, GL_TEXTURE_SWIZZLE_G, +GL_DEPTH_STENCIL_ATTACHMENT, GL_TRIANGLE_STRIP_ADJACENCY, GL_ADD, GL_TEXTURE_BINDING_1D_ARRAY, GL_TEXTURE_SWIZZLE_B, +GL_TEXTURE_SWIZZLE_A, GL_FUNC_ADD, GL_MODELVIEW_STACK_DEPTH, GL_FLOAT_MAT4x3, GL_POINT_FADE_THRESHOLD_SIZE, +GL_INT_SAMPLER_BUFFER, GL_UNPACK_ALIGNMENT, GL_LINE_STRIP, GL_PACK_ROW_LENGTH, GL_COLOR_MATERIAL, +GL_MAX_PIXEL_MAP_TABLE, GL_COLOR, GL_POLYGON_STIPPLE, GL_BITMAP, GL_DYNAMIC_READ, +GL_COMPRESSED_LUMINANCE, GL_LUMINANCE12_ALPHA12, GL_DEPTH_STENCIL, GL_RG8UI, GL_MAX_VERTEX_OUTPUT_COMPONENTS, +GL_KEEP, GL_TEXTURE_INTENSITY_SIZE, GL_PROXY_TEXTURE_2D, GL_SYNC_CONDITION, GL_ACTIVE_UNIFORM_MAX_LENGTH, +GL_OR, GL_MAP_INVALIDATE_RANGE_BIT, GL_TEXTURE23, GL_TEXTURE22, GL_TEXTURE21, +GL_TEXTURE20, GL_TEXTURE27, GL_TEXTURE26, GL_TEXTURE25, GL_TEXTURE24, +GL_R8_SNORM, GL_TEXTURE29, GL_TEXTURE28, GL_SAMPLER_1D_ARRAY, GL_ELEMENT_ARRAY_BUFFER_BINDING, +GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER, GL_TRIANGLES_ADJACENCY, GL_PIXEL_MODE_BIT, GL_LINE_LOOP, GL_ALPHA_SCALE, +GL_READ_BUFFER, GL_PACK_SKIP_PIXELS, GL_BACK_RIGHT, GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, GL_SUBPIXEL_BITS, +GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS, GL_GEQUAL, GL_ALPHA_TEST, GL_SLUMINANCE8_ALPHA8, GL_SAMPLER_2D_MULTISAMPLE, +GL_LUMINANCE4_ALPHA4, GL_RGBA8UI, GL_UNIFORM_OFFSET, GL_TEXTURE1, GL_OBJECT_PLANE, +GL_UNSIGNED_INT_SAMPLER_CUBE, GL_SUBTRACT, GL_TIME_ELAPSED, GL_SECONDARY_COLOR_ARRAY_SIZE, GL_COMPRESSED_RED_RGTC1, +GL_READ_WRITE, GL_BUFFER_ACCESS, GL_LINES_ADJACENCY, GL_ARRAY_BUFFER_BINDING, GL_INDEX_WRITEMASK, +GL_TEXTURE_2D, GL_VERTEX_ARRAY_STRIDE, GL_DYNAMIC_DRAW, GL_4D_COLOR_TEXTURE, GL_NICEST, +GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, GL_UNPACK_ROW_LENGTH, GL_CURRENT_PROGRAM, GL_BUFFER_MAPPED, GL_EYE_LINEAR, +GL_STREAM_DRAW, GL_POLYGON_SMOOTH_HINT, GL_INDEX, GL_MAX_UNIFORM_BUFFER_BINDINGS, GL_SIGNALED, +GL_FRAMEBUFFER, GL_SPECULAR, GL_TEXTURE_BINDING_2D, GL_GENERATE_MIPMAP, GL_DOMAIN, +GL_COLOR_ARRAY_SIZE, GL_STENCIL_BACK_FAIL, GL_POLYGON_OFFSET_FACTOR, GL_R8UI, GL_SYNC_FLUSH_COMMANDS_BIT, +GL_DRAW_FRAMEBUFFER_BINDING, GL_STATIC_DRAW, GL_MODELVIEW, GL_PIXEL_MAP_I_TO_B_SIZE, GL_TRIANGLES, +GL_SAMPLER_2D_ARRAY_SHADOW, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_UNIFORM_MATRIX_STRIDE, GL_MAX_DEPTH_TEXTURE_SAMPLES, GL_QUERY_BY_REGION_WAIT, +GL_TEXTURE_RESIDENT, GL_SLUMINANCE, GL_SRGB8_ALPHA8, GL_FOG, GL_FOG_COORD, +GL_SAMPLER_2D_ARRAY, GL_POSITION, GL_RENDERER, GL_MIRRORED_REPEAT, GL_RG, +GL_PIXEL_MAP_B_TO_B, GL_LINE_STIPPLE_PATTERN, GL_STENCIL_BACK_FUNC, GL_PIXEL_MAP_R_TO_R_SIZE, GL_MAP1_TEXTURE_COORD_2, +GL_TEXTURE_BINDING_3D, GL_COLOR_LOGIC_OP, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, GL_UNIFORM_BLOCK_INDEX, GL_ENABLE_BIT, +GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, GL_MAX_VERTEX_ATTRIBS, GL_SPHERE_MAP, GL_CONSTANT, GL_LINE_WIDTH_RANGE, +GL_XOR, GL_PROJECTION, GL_LESS, GL_COPY_PIXEL_TOKEN, GL_FRAMEBUFFER_UNDEFINED, +GL_2_BYTES, GL_TEXTURE_STENCIL_SIZE, GL_CURRENT_RASTER_INDEX, GL_EMISSION, GL_COMPRESSED_SRGB, +GL_TEXTURE_DEPTH_TYPE, GL_TEXTURE_ENV_MODE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_INT_SAMPLER_1D, GL_CURRENT_RASTER_COLOR, +GL_PROXY_TEXTURE_2D_ARRAY, GL_QUAD_STRIP, GL_REPEAT, GL_ACCUM, GL_T2F_C4F_N3F_V3F, +GL_TEXTURE_INTENSITY_TYPE, GL_INTENSITY16, GL_VERTEX_ARRAY_TYPE, GL_VERTEX_ARRAY_SIZE, GL_TEXTURE_GREEN_SIZE, +GL_CLIENT_ALL_ATTRIB_BITS, GL_VALIDATE_STATUS, GL_RG16, GL_LIGHT7, GL_STENCIL_BACK_VALUE_MASK, +GL_SCISSOR_TEST, GL_STENCIL_BUFFER_BIT, GL_TEXTURE_2D_MULTISAMPLE, GL_SAMPLER_1D_ARRAY_SHADOW, GL_SRC1_RGB, +GL_BLEND_EQUATION_ALPHA, GL_ACTIVE_ATTRIBUTES, GL_COLOR_ATTACHMENT31, GL_LIGHTING, GL_CURRENT_RASTER_DISTANCE, +GL_VERTEX_ARRAY_POINTER, GL_ATTACHED_SHADERS, GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, GL_QUERY_BY_REGION_NO_WAIT, GL_SAMPLE_COVERAGE_INVERT, +GL_LINES, GL_TEXTURE18, GL_TEXTURE19, GL_TEXTURE16, GL_TEXTURE17, +GL_TEXTURE14, GL_TEXTURE15, GL_TEXTURE12, GL_TEXTURE13, GL_TEXTURE10, +GL_TEXTURE11, GL_RGB, GL_SEPARATE_SPECULAR_COLOR, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_TRANSFORM_FEEDBACK_BUFFER_START, +GL_MAX_PROGRAM_TEXEL_OFFSET, GL_STACK_OVERFLOW, GL_MAP1_VERTEX_4, GL_TEXTURE_COMPRESSION_HINT, GL_RGBA32F, +GL_RGBA32I, GL_COLOR_ARRAY_BUFFER_BINDING, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_TRANSPOSE_COLOR_MATRIX, GL_STENCIL_WRITEMASK, +GL_RG8, GL_FOG_COORDINATE_ARRAY_POINTER, GL_STENCIL_BACK_PASS_DEPTH_PASS, GL_INVALID_VALUE, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, +GL_VERSION, GL_MAP_UNSYNCHRONIZED_BIT, GL_PRIMITIVE_RESTART, GL_COLOR_ARRAY_STRIDE, GL_MAX_ELEMENTS_INDICES, +GL_SRC_ALPHA, GL_TEXTURE_3D, GL_GEOMETRY_VERTICES_OUT, GL_RGB8, GL_INDEX_ARRAY_POINTER, +GL_MATRIX_MODE, GL_UNIFORM_ARRAY_STRIDE, GL_TEXTURE_SAMPLES, GL_RGB4, GL_RGB5, +GL_CULL_FACE, GL_PIXEL_MAP_I_TO_I_SIZE, GL_SAMPLE_COVERAGE_VALUE, GL_PROXY_TEXTURE_CUBE_MAP, GL_SECONDARY_COLOR_ARRAY_STRIDE, +GL_COMPRESSED_SIGNED_RG_RGTC2, GL_COLOR_INDEXES, GL_RG32UI, GL_OPERAND1_ALPHA, GL_NORMALIZE, +GL_NEVER, GL_STENCIL_VALUE_MASK, GL_BLEND_DST, GL_STENCIL_BACK_WRITEMASK, GL_BLUE_SCALE, +GL_TEXTURE_INTERNAL_FORMAT, GL_LOAD, GL_FRAMEBUFFER_COMPLETE, GL_COPY_READ_BUFFER, GL_INDEX_ARRAY_STRIDE, +GL_FOG_COORD_ARRAY_POINTER, GL_MAP2_VERTEX_3, GL_TEXTURE_SWIZZLE_RGBA, GL_DEPTH_COMPONENT32, GL_RGBA, +GL_READ_FRAMEBUFFER, GL_NORMAL_ARRAY, GL_COLOR_SUM, GL_BLEND_EQUATION_RGB, GL_MAP2_COLOR_4, +GL_VENDOR, GL_TEXTURE_2D_ARRAY, GL_ACCUM_BUFFER_BIT, GL_EDGE_FLAG, GL_OBJECT_TYPE, +GL_C4UB_V3F, GL_INTERPOLATE, GL_BUFFER_ACCESS_FLAGS, GL_LINK_STATUS, GL_PACK_SKIP_IMAGES, +GL_FLOAT_MAT2x3, GL_COMBINE, GL_FLOAT_MAT2x4, GL_Q, GL_SECONDARY_COLOR_ARRAY, +GL_INDEX_LOGIC_OP, GL_SEPARATE_ATTRIBS, GL_PRIMITIVES_GENERATED, GL_MAX, GL_LUMINANCE, +GL_INVALID_INDEX, GL_MAP2_VERTEX_4, GL_AUTO_NORMAL, GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, GL_CURRENT_RASTER_SECONDARY_COLOR, +GL_SAMPLER_1D_SHADOW, GL_ACCUM_RED_BITS, GL_SAMPLER_2D_SHADOW, GL_TEXTURE_MATRIX, GL_TRANSPOSE_PROJECTION_MATRIX, +GL_CLIP_DISTANCE6, GL_RG16F, GL_MAX_NAME_STACK_DEPTH, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, GL_TEXTURE_BIT, +GL_RG16I, GL_WRITE_ONLY, GL_STENCIL_ATTACHMENT, GL_CLIENT_VERTEX_ARRAY_BIT, GL_SAMPLE_COVERAGE, +GL_INDEX_ARRAY_BUFFER_BINDING, GL_SHININESS, GL_DRAW_FRAMEBUFFER, GL_TEXTURE_LOD_BIAS, GL_RGB10_A2UI +; + diff --git a/demos/external/sources/glad/gl/gles2.d b/demos/external/sources/glad/gl/gles2.d new file mode 100644 index 0000000..18fea32 --- /dev/null +++ b/demos/external/sources/glad/gl/gles2.d @@ -0,0 +1,183 @@ +module glad.gl.gles2; + + +public import glad.gl.types; +public import glad.gl.funcs : +glUniformMatrix2fv, glBeginTransformFeedback, glFlush, glGetRenderbufferParameteriv, glClearColor, +glClearBufferiv, glStencilMaskSeparate, glGetVertexAttribPointerv, glLinkProgram, glBindTexture, +glGetStringi, glFenceSync, glUniform3ui, glFramebufferRenderbuffer, glGetString, +glCompressedTexSubImage3D, glDetachShader, glVertexAttribI4uiv, glEndQuery, glBindSampler, +glLineWidth, glUniform2fv, glGetIntegeri_v, glCompileShader, glGetTransformFeedbackVarying, +glDeleteTextures, glStencilOpSeparate, glStencilFuncSeparate, glBindBufferRange, glVertexAttrib4f, +glUniform2f, glRenderbufferStorage, glDeleteShader, glGetBufferParameteri64v, glDepthRangef, +glUniform4iv, glGetTexParameteriv, glClearStencil, glUniformMatrix2x3fv, glGetUniformiv, +glGenTransformFeedbacks, glGetVertexAttribIuiv, glSampleCoverage, glSamplerParameteri, glGenTextures, +glSamplerParameterf, glDepthFunc, glCompressedTexSubImage2D, glUniform1f, glGetVertexAttribfv, +glProgramBinary, glGetTexParameterfv, glCreateShader, glIsBuffer, glUniform1i, +glGenRenderbuffers, glCopyTexSubImage2D, glCompressedTexImage2D, glDisable, glUniform2i, +glBlendFuncSeparate, glGetProgramiv, glColorMask, glHint, glFramebufferTextureLayer, +glBlendEquation, glGetUniformLocation, glBindFramebuffer, glEndTransformFeedback, glCullFace, +glUniformMatrix3x2fv, glTexStorage2D, glUniform4fv, glGetInternalformativ, glDeleteProgram, +glIsSampler, glVertexAttribDivisor, glGenQueries, glWaitSync, glAttachShader, +glUniformMatrix4x3fv, glUniform3i, glClearBufferfv, glDeleteTransformFeedbacks, glShaderBinary, +glCheckFramebufferStatus, glTexSubImage3D, glGetInteger64i_v, glDeleteSamplers, glCopyTexImage2D, +glUniform3f, glBlitFramebuffer, glBindAttribLocation, glUniformMatrix4x2fv, glBlendEquationSeparate, +glDrawElements, glGetShaderSource, glUniform2iv, glGetQueryObjectuiv, glGenVertexArrays, +glBindBufferBase, glBufferSubData, glUniform1iv, glGetBufferParameteriv, glMapBufferRange, +glReadBuffer, glTexStorage3D, glClientWaitSync, glDrawArraysInstanced, glViewport, +glGenerateMipmap, glGetShaderiv, glUniformMatrix3x4fv, glUniform2ui, glVertexAttrib3f, +glGetActiveAttrib, glBlendColor, glGetShaderPrecisionFormat, glResumeTransformFeedback, glUnmapBuffer, +glGetUniformfv, glDisableVertexAttribArray, glShaderSource, glBindRenderbuffer, glDeleteRenderbuffers, +glIsSync, glReleaseShaderCompiler, glDeleteFramebuffers, glDrawArrays, glUniform1ui, +glIsProgram, glTexSubImage2D, glGetSynciv, glVertexAttrib1fv, glClear, +glVertexAttrib4fv, glProgramParameteri, glIsTransformFeedback, glUniform4i, glActiveTexture, +glEnableVertexAttribArray, glDrawRangeElements, glBindBuffer, glIsEnabled, glStencilOp, +glReadPixels, glStencilMask, glUniform4f, glFramebufferTexture2D, glGetFramebufferAttachmentParameteriv, +glUniformMatrix2x4fv, glUniform3fv, glBufferData, glCompressedTexImage3D, glDeleteSync, +glPauseTransformFeedback, glGetError, glGetActiveUniformBlockName, glGetVertexAttribiv, glTexParameteriv, +glGetProgramBinary, glVertexAttrib3fv, glGetFloatv, glUniform3iv, glVertexAttrib2fv, +glGetShaderInfoLog, glGenFramebuffers, glDrawBuffers, glGetActiveUniformBlockiv, glStencilFunc, +glGetIntegerv, glGetAttachedShaders, glUniformBlockBinding, glIsRenderbuffer, glGetBufferPointerv, +glDeleteVertexArrays, glIsShader, glRenderbufferStorageMultisample, glUniform4uiv, glIsQuery, +glIsVertexArray, glUseProgram, glVertexAttribI4iv, glGetQueryiv, glTexImage2D, +glGetProgramInfoLog, glGetSamplerParameterfv, glBindTransformFeedback, glUniform4ui, glSamplerParameterfv, +glClearBufferuiv, glBindVertexArray, glIsTexture, glGetUniformIndices, glUniform1fv, +glGetInteger64v, glVertexAttribPointer, glTexParameterfv, glInvalidateSubFramebuffer, glUniformMatrix3fv, +glScissor, glEnable, glGetActiveUniformsiv, glVertexAttribI4i, glVertexAttribI4ui, +glGetFragDataLocation, glUniform2uiv, glGenBuffers, glFinish, glGetAttribLocation, +glBeginQuery, glVertexAttribIPointer, glBlendFunc, glCreateProgram, glTexImage3D, +glGenSamplers, glGetSamplerParameteriv, glIsFramebuffer, glFlushMappedBufferRange, glUniformMatrix4fv, +glCopyBufferSubData, glInvalidateFramebuffer, glUniform1uiv, glTransformFeedbackVaryings, glVertexAttrib2f, +glVertexAttrib1f, glCopyTexSubImage3D, glDepthMask, glGetUniformuiv, glGetUniformBlockIndex, +glGetVertexAttribIiv, glGetActiveUniform, glTexParameterf, glClearBufferfi, glTexParameteri, +glFrontFace, glClearDepthf, glDeleteBuffers, glSamplerParameteriv, glDrawElementsInstanced, +glGetBooleanv, glPixelStorei, glValidateProgram, glPolygonOffset, glDeleteQueries, +glUniform3uiv; + +public import glad.gl.enums : +GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, GL_UNSIGNED_INT_VEC2, GL_UNSIGNED_INT_VEC3, GL_UNSIGNED_INT_VEC4, GL_UNSIGNED_SHORT_5_6_5, +GL_VERTEX_ATTRIB_ARRAY_SIZE, GL_DEPTH_ATTACHMENT, GL_DITHER, GL_TRANSFORM_FEEDBACK_PAUSED, GL_RGB16UI, +GL_QUERY_RESULT, GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, GL_FLOAT_VEC2, GL_FLOAT_VEC3, GL_FLOAT_VEC4, +GL_FLOAT, GL_RGB32UI, GL_TEXTURE_MAX_LOD, GL_BUFFER_MAP_OFFSET, GL_BUFFER_SIZE, +GL_RGB9_E5, GL_UNIFORM_BUFFER_START, GL_COMPRESSED_R11_EAC, GL_RGBA32UI, GL_UNSIGNED_INT_SAMPLER_2D, +GL_TEXTURE_MIN_LOD, GL_TEXTURE8, GL_TEXTURE9, GL_TEXTURE4, GL_TEXTURE5, +GL_TEXTURE6, GL_TEXTURE7, GL_TEXTURE0, GL_LINEAR_MIPMAP_LINEAR, GL_TEXTURE2, +GL_TEXTURE3, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_BLEND_EQUATION, GL_BYTE, +GL_BOOL_VEC3, GL_BOOL_VEC2, GL_TIMEOUT_IGNORED, GL_MAX_VARYING_VECTORS, GL_RENDERBUFFER_SAMPLES, +GL_ONE, GL_RG, GL_COLOR_CLEAR_VALUE, GL_MAX_SAMPLES, GL_BUFFER_USAGE, +GL_UNPACK_IMAGE_HEIGHT, GL_FLOAT_MAT3x2, GL_TRIANGLE_STRIP, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRANSFORM_FEEDBACK_BUFFER_BINDING, +GL_FLOAT_MAT3x4, GL_COLOR_ATTACHMENT28, GL_COLOR_ATTACHMENT29, GL_COLOR_ATTACHMENT24, GL_COLOR_ATTACHMENT25, +GL_COLOR_ATTACHMENT26, GL_COLOR_ATTACHMENT27, GL_COLOR_ATTACHMENT20, GL_COLOR_ATTACHMENT21, GL_COLOR_ATTACHMENT22, +GL_COLOR_ATTACHMENT23, GL_TRANSFORM_FEEDBACK_BUFFER, GL_VERTEX_ARRAY_BINDING, GL_UNSIGNED_SHORT_5_5_5_1, GL_TIMEOUT_EXPIRED, +GL_COMPRESSED_RGB8_ETC2, GL_SIGNED_NORMALIZED, GL_STENCIL_FUNC, GL_MAX_TEXTURE_LOD_BIAS, GL_ALIASED_LINE_WIDTH_RANGE, +GL_DECR, GL_BACK, GL_TEXTURE_COMPARE_FUNC, GL_TRANSFORM_FEEDBACK_BUFFER_MODE, GL_INT, +GL_COMPRESSED_SIGNED_RG11_EAC, GL_POLYGON_OFFSET_FILL, GL_MINOR_VERSION, GL_FRONT_AND_BACK, GL_R8, +GL_RGB_INTEGER, GL_STENCIL_CLEAR_VALUE, GL_SRGB, GL_GREEN_BITS, GL_SYNC_FENCE, +GL_ONE_MINUS_CONSTANT_COLOR, GL_SHADING_LANGUAGE_VERSION, GL_RGB8_SNORM, GL_UNPACK_SKIP_PIXELS, GL_TEXTURE_IMMUTABLE_LEVELS, +GL_FRAGMENT_SHADER, GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, GL_FRAGMENT_SHADER_DERIVATIVE_HINT, +GL_NO_ERROR, GL_VIEWPORT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, GL_BLEND_SRC_ALPHA, GL_DRAW_BUFFER6, +GL_DRAW_BUFFER7, GL_DRAW_BUFFER4, GL_DRAW_BUFFER5, GL_DRAW_BUFFER2, GL_DRAW_BUFFER3, +GL_DRAW_BUFFER0, GL_DRAW_BUFFER1, GL_COMPRESSED_SRGB8_ETC2, GL_QUERY_RESULT_AVAILABLE, GL_DRAW_BUFFER8, +GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, GL_MAX_DRAW_BUFFERS, GL_KEEP, GL_DELETE_STATUS, GL_R32UI, +GL_RGBA8_SNORM, GL_INT_SAMPLER_3D, GL_SRC_COLOR, GL_SAMPLER_BINDING, GL_DEPTH24_STENCIL8, +GL_SAMPLE_BUFFERS, GL_MAJOR_VERSION, GL_STATIC_COPY, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, GL_EXTENSIONS, +GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_TYPE, GL_COPY_READ_BUFFER_BINDING, GL_TEXTURE_COMPARE_MODE, GL_ANY_SAMPLES_PASSED, +GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, GL_DEPTH_BUFFER_BIT, GL_STENCIL_BACK_PASS_DEPTH_FAIL, GL_UNIFORM_BUFFER, GL_MAP_WRITE_BIT, +GL_VERTEX_ATTRIB_ARRAY_POINTER, GL_ALIASED_POINT_SIZE_RANGE, GL_CCW, GL_MAP_INVALIDATE_BUFFER_BIT, GL_DEPTH_COMPONENT24, +GL_UNSIGNED_INT_5_9_9_9_REV, GL_DEPTH_TEST, GL_SYNC_GPU_COMMANDS_COMPLETE, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, +GL_MAX_VERTEX_UNIFORM_BLOCKS, GL_STREAM_READ, GL_LINEAR, GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_FUNC_SUBTRACT, +GL_R32F, GL_MAX_VARYING_COMPONENTS, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, GL_IMPLEMENTATION_COLOR_READ_FORMAT, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, +GL_MAX_ELEMENT_INDEX, GL_COLOR_ATTACHMENT15, GL_COLOR_ATTACHMENT14, GL_HIGH_FLOAT, GL_DEPTH_RANGE, +GL_GREATER, GL_CLAMP_TO_EDGE, GL_COLOR_ATTACHMENT13, GL_COLOR_ATTACHMENT12, GL_NEAREST, +GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_COLOR_ATTACHMENT19, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER, GL_MAX_TEXTURE_IMAGE_UNITS, GL_RGB32F, +GL_FLOAT_MAT2, GL_FLOAT_MAT3, GL_FRONT_FACE, GL_DEPTH, GL_FLOAT_MAT4, +GL_RENDERBUFFER_GREEN_SIZE, GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT, GL_TEXTURE30, GL_TEXTURE31, +GL_RG8I, GL_RGBA8I, GL_RG8UI, GL_DEPTH_CLEAR_VALUE, GL_BUFFER_MAP_POINTER, +GL_RENDERBUFFER_BINDING, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, GL_STENCIL_REF, GL_MAX_3D_TEXTURE_SIZE, GL_COPY_WRITE_BUFFER_BINDING, +GL_COPY_WRITE_BUFFER, GL_BLEND, GL_MIRRORED_REPEAT, GL_R16UI, GL_TEXTURE_BINDING_3D, +GL_UNSIGNED_SHORT, GL_MIN, GL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_TEXTURE, +GL_COLOR_BUFFER_BIT, GL_DONT_CARE, GL_ACTIVE_UNIFORMS, GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_MAX_VERTEX_UNIFORM_VECTORS, +GL_TEXTURE_BINDING_CUBE_MAP, GL_SAMPLER_2D, GL_INVALID_VALUE, GL_DRAW_BUFFER12, GL_NEAREST_MIPMAP_NEAREST, +GL_NUM_COMPRESSED_TEXTURE_FORMATS, GL_PACK_SKIP_ROWS, GL_TEXTURE_MAG_FILTER, GL_TEXTURE1, GL_BLEND_EQUATION_RGB, +GL_LINK_STATUS, GL_TEXTURE_MAX_LEVEL, GL_R32I, GL_BLEND_COLOR, GL_ALPHA_BITS, +GL_BOOL_VEC4, GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, GL_ONE_MINUS_CONSTANT_ALPHA, GL_NEAREST_MIPMAP_LINEAR, GL_INT_2_10_10_10_REV, +GL_SAMPLER_CUBE_SHADOW, GL_WAIT_FAILED, GL_MAX_TEXTURE_SIZE, GL_RG32F, GL_UNSIGNED_INT_SAMPLER_2D_ARRAY, +GL_ARRAY_BUFFER, GL_DEPTH_COMPONENT16, GL_UNSIGNALED, GL_RGB32I, GL_BLEND_SRC_RGB, +GL_FRAMEBUFFER_UNDEFINED, GL_SYNC_FLAGS, GL_FALSE, GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS, GL_ONE_MINUS_SRC_ALPHA, +GL_RG32I, GL_RENDERBUFFER_INTERNAL_FORMAT, GL_NUM_SHADER_BINARY_FORMATS, GL_RGBA16I, GL_R8I, +GL_SAMPLE_ALPHA_TO_COVERAGE, GL_INT_SAMPLER_2D, GL_STENCIL_BITS, GL_STENCIL_PASS_DEPTH_FAIL, GL_RED, +GL_FUNC_REVERSE_SUBTRACT, GL_RGBA8UI, GL_GREEN, GL_INVALID_OPERATION, GL_RED_INTEGER, +GL_NONE, GL_STENCIL_BACK_PASS_DEPTH_PASS, GL_COLOR_ATTACHMENT5, GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS, GL_COLOR_ATTACHMENT7, +GL_UNIFORM_BLOCK_NAME_LENGTH, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT3, GL_COLOR_ATTACHMENT2, +GL_UNIFORM_BLOCK_INDEX, GL_FRAMEBUFFER_DEFAULT, GL_RGBA16UI, GL_COLOR_ATTACHMENT9, GL_COLOR_ATTACHMENT8, +GL_COLOR_ATTACHMENT10, GL_FRONT, GL_SCISSOR_BOX, GL_UNIFORM_BLOCK_DATA_SIZE, GL_DEPTH_WRITEMASK, +GL_CULL_FACE_MODE, GL_MAX_FRAGMENT_UNIFORM_VECTORS, GL_NUM_EXTENSIONS, GL_UNIFORM_IS_ROW_MAJOR, GL_MAX_UNIFORM_BLOCK_SIZE, +GL_BOOL, GL_MAX_COMBINED_UNIFORM_BLOCKS, GL_FRAMEBUFFER_BINDING, GL_UNSIGNED_INT_24_8, GL_COMPRESSED_TEXTURE_FORMATS, +GL_ALPHA, GL_COLOR_WRITEMASK, GL_DST_COLOR, GL_UNSIGNED_INT, GL_DEPTH_FUNC, +GL_ALWAYS, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_INVALID_ENUM, GL_PROGRAM_BINARY_LENGTH, +GL_STENCIL_BACK_VALUE_MASK, GL_INT_SAMPLER_2D_ARRAY, GL_DEPTH_COMPONENT, GL_SCISSOR_TEST, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, +GL_SHADER_TYPE, GL_COMPARE_REF_TO_TEXTURE, GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE, GL_TRUE, +GL_TEXTURE_MIN_FILTER, GL_REPLACE, GL_BLUE_BITS, GL_RG_INTEGER, GL_TEXTURE_SWIZZLE_R, +GL_VERTEX_ATTRIB_ARRAY_STRIDE, GL_EQUAL, GL_TEXTURE_SWIZZLE_G, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER_HEIGHT, +GL_RG16UI, GL_INTERLEAVED_ATTRIBS, GL_TEXTURE_SWIZZLE_A, GL_POLYGON_OFFSET_UNITS, GL_LOW_FLOAT, +GL_HALF_FLOAT, GL_FLOAT_MAT4x3, GL_DYNAMIC_COPY, GL_COLOR_ATTACHMENT6, GL_UNPACK_ALIGNMENT, +GL_ALREADY_SIGNALED, GL_LINE_STRIP, GL_STREAM_COPY, GL_PACK_ROW_LENGTH, GL_NUM_SAMPLE_COUNTS, +GL_MEDIUM_INT, GL_TEXTURE_CUBE_MAP, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, GL_COLOR, GL_RENDERBUFFER_DEPTH_SIZE, +GL_DYNAMIC_READ, GL_PROGRAM_BINARY_FORMATS, GL_LOW_INT, GL_DEPTH_STENCIL, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, +GL_MAX_VERTEX_OUTPUT_COMPONENTS, GL_POINTS, GL_COMPRESSED_RG11_EAC, GL_RENDERBUFFER_BLUE_SIZE, GL_UNIFORM_NAME_LENGTH, +GL_FASTEST, GL_SYNC_CONDITION, GL_ACTIVE_UNIFORM_MAX_LENGTH, GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, GL_MAP_INVALIDATE_RANGE_BIT, +GL_TEXTURE23, GL_TEXTURE22, GL_TEXTURE21, GL_TEXTURE20, GL_TEXTURE27, +GL_TEXTURE26, GL_TEXTURE25, GL_TEXTURE24, GL_R8_SNORM, GL_TEXTURE29, +GL_TEXTURE28, GL_ELEMENT_ARRAY_BUFFER_BINDING, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, +GL_LINE_LOOP, GL_READ_BUFFER, GL_MAP_FLUSH_EXPLICIT_BIT, GL_PACK_SKIP_PIXELS, GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS, +GL_SUBPIXEL_BITS, GL_R16F, GL_GEQUAL, GL_READ_FRAMEBUFFER, GL_UNIFORM_BLOCK_BINDING, +GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, GL_LINE_WIDTH, GL_UNIFORM_OFFSET, GL_LEQUAL, GL_TRANSFORM_FEEDBACK, +GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GL_UNSIGNED_INT_SAMPLER_CUBE, GL_COLOR_ATTACHMENT4, GL_UNIFORM_SIZE, GL_FUNC_ADD, +GL_FLOAT_MAT4x2, GL_SHADER_SOURCE_LENGTH, GL_CURRENT_VERTEX_ATTRIB, GL_ARRAY_BUFFER_BINDING, GL_TEXTURE_2D, +GL_DYNAMIC_DRAW, GL_OUT_OF_MEMORY, GL_NICEST, GL_IMPLEMENTATION_COLOR_READ_TYPE, GL_UNPACK_ROW_LENGTH, +GL_CURRENT_PROGRAM, GL_BUFFER_MAPPED, GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, GL_RASTERIZER_DISCARD, GL_NUM_PROGRAM_BINARY_FORMATS, +GL_STREAM_DRAW, GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER, GL_MAX_UNIFORM_BUFFER_BINDINGS, GL_SIGNALED, GL_FRAMEBUFFER, +GL_UNPACK_SKIP_ROWS, GL_MEDIUM_FLOAT, GL_STENCIL_TEST, GL_R11F_G11F_B10F, GL_SRGB8, +GL_LUMINANCE_ALPHA, GL_PIXEL_UNPACK_BUFFER_BINDING, GL_INVERT, GL_STENCIL_BACK_FAIL, GL_POLYGON_OFFSET_FACTOR, +GL_TRANSFORM_FEEDBACK_VARYINGS, GL_DEPTH_COMPONENT32F, GL_TRIANGLE_FAN, GL_SYNC_FLUSH_COMMANDS_BIT, GL_ONE_MINUS_DST_ALPHA, +GL_DRAW_FRAMEBUFFER_BINDING, GL_MAX_ELEMENTS_VERTICES, GL_STENCIL_BACK_WRITEMASK, GL_INVALID_FRAMEBUFFER_OPERATION, GL_BUFFER_ACCESS_FLAGS, +GL_COMPRESSED_RGBA8_ETC2_EAC, GL_UNIFORM_BUFFER_SIZE, GL_TRIANGLES, GL_SAMPLER_2D_ARRAY_SHADOW, GL_DEPTH32F_STENCIL8, +GL_MAX_ARRAY_TEXTURE_LAYERS, GL_RED_BITS, GL_UNIFORM_MATRIX_STRIDE, GL_MAX_SERVER_WAIT_TIMEOUT, GL_SRGB8_ALPHA8, +GL_RGBA16F, GL_PACK_ALIGNMENT, GL_SAMPLER_2D_ARRAY, GL_RENDERER, GL_MAX_COLOR_ATTACHMENTS, +GL_ACTIVE_UNIFORM_BLOCKS, GL_UNPACK_SKIP_IMAGES, GL_STENCIL_BACK_FUNC, GL_RGB16I, GL_ACTIVE_TEXTURE, +GL_TEXTURE_BASE_LEVEL, GL_RGB16F, GL_COMPRESSED_SIGNED_R11_EAC, GL_UNSIGNED_INT_SAMPLER_3D, GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, +GL_TEXTURE_WRAP_R, GL_INT_VEC4, GL_INT_VEC3, GL_INT_VEC2, GL_STENCIL_FAIL, +GL_MAX_VERTEX_ATTRIBS, GL_CONDITION_SATISFIED, GL_TEXTURE_IMMUTABLE_FORMAT, GL_FRAMEBUFFER_UNSUPPORTED, GL_DST_ALPHA, +GL_LESS, GL_MAX_CUBE_MAP_TEXTURE_SIZE, GL_RGB565, GL_TRANSFORM_FEEDBACK_BINDING, GL_RENDERBUFFER_WIDTH, +GL_READ_FRAMEBUFFER_BINDING, GL_RGBA4, GL_DRAW_BUFFER10, GL_DRAW_BUFFER11, GL_RGBA8, +GL_DRAW_BUFFER13, GL_DRAW_BUFFER14, GL_DRAW_BUFFER15, GL_INFO_LOG_LENGTH, GL_PRIMITIVE_RESTART_FIXED_INDEX, +GL_SRC_ALPHA_SATURATE, GL_RENDERBUFFER_STENCIL_SIZE, GL_REPEAT, GL_R16I, GL_RG8_SNORM, +GL_PIXEL_PACK_BUFFER, GL_STATIC_READ, GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER, GL_VALIDATE_STATUS, +GL_MAP_READ_BIT, GL_STENCIL, GL_STENCIL_BUFFER_BIT, GL_TEXTURE_SWIZZLE_B, GL_COLOR_ATTACHMENT17, +GL_BLEND_EQUATION_ALPHA, GL_RGBA_INTEGER, GL_ACTIVE_ATTRIBUTES, GL_MAX_RENDERBUFFER_SIZE, GL_COLOR_ATTACHMENT31, +GL_COLOR_ATTACHMENT30, GL_STENCIL_PASS_DEPTH_PASS, GL_INCR_WRAP, GL_RENDERBUFFER_ALPHA_SIZE, GL_HIGH_INT, +GL_COLOR_ATTACHMENT16, GL_DECR_WRAP, GL_ATTACHED_SHADERS, GL_MAX_FRAGMENT_INPUT_COMPONENTS, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, +GL_LINES, GL_TEXTURE18, GL_TEXTURE19, GL_TEXTURE16, GL_TEXTURE17, +GL_TEXTURE14, GL_GENERATE_MIPMAP_HINT, GL_TEXTURE12, GL_COLOR_ATTACHMENT11, GL_TEXTURE10, +GL_MAX_FRAGMENT_UNIFORM_BLOCKS, GL_BLEND_DST_ALPHA, GL_RGB, GL_INT_SAMPLER_CUBE, GL_CURRENT_QUERY, +GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_RGB5_A1, GL_VERTEX_SHADER, GL_TRANSFORM_FEEDBACK_BUFFER_START, GL_MAX_PROGRAM_TEXEL_OFFSET, +GL_SHADER_BINARY_FORMATS, GL_CONSTANT_COLOR, GL_RGBA32F, GL_RGBA32I, GL_VERTEX_ATTRIB_ARRAY_TYPE, +GL_PIXEL_UNPACK_BUFFER, GL_LINEAR_MIPMAP_NEAREST, GL_STENCIL_WRITEMASK, GL_RG8, GL_RGB10_A2, +GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE, GL_VERSION, GL_MAP_UNSYNCHRONIZED_BIT, GL_ZERO, GL_ELEMENT_ARRAY_BUFFER, +GL_SYNC_STATUS, GL_BUFFER_MAP_LENGTH, GL_MAX_ELEMENTS_INDICES, GL_UNSIGNED_NORMALIZED, GL_CONSTANT_ALPHA, +GL_SRC_ALPHA, GL_TEXTURE_3D, GL_FIXED, GL_RGB8, GL_SAMPLE_COVERAGE_INVERT, +GL_NOTEQUAL, GL_UNIFORM_ARRAY_STRIDE, GL_FLOAT_32_UNSIGNED_INT_24_8_REV, GL_INCR, GL_CULL_FACE, +GL_SAMPLE_COVERAGE_VALUE, GL_RENDERBUFFER_RED_SIZE, GL_MAX_VIEWPORT_DIMS, GL_RG32UI, GL_NEVER, +GL_TEXTURE15, GL_STENCIL_VALUE_MASK, GL_TEXTURE13, GL_DRAW_BUFFER9, GL_COMPILE_STATUS, +GL_FRAMEBUFFER_COMPLETE, GL_TEXTURE11, GL_COPY_READ_BUFFER, GL_SHADER_COMPILER, GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, +GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, GL_LUMINANCE, GL_RGBA, GL_SHORT, GL_BLUE, +GL_CW, GL_MIN_PROGRAM_TEXEL_OFFSET, GL_UNSIGNED_BYTE, GL_MAX_VERTEX_UNIFORM_COMPONENTS, GL_VENDOR, +GL_TEXTURE_2D_ARRAY, GL_UNSIGNED_INT_10F_11F_11F_REV, GL_TEXTURE_BINDING_2D, GL_OBJECT_TYPE, GL_R8UI, +GL_STATIC_DRAW, GL_RENDERBUFFER, GL_FLOAT_MAT2x3, GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, GL_FLOAT_MAT2x4, +GL_RGB8I, GL_COLOR_ATTACHMENT18, GL_TRANSFORM_FEEDBACK_BUFFER_SIZE, GL_TRANSFORM_FEEDBACK_ACTIVE, GL_SEPARATE_ATTRIBS, +GL_SAMPLER_3D, GL_MAX, GL_STENCIL_INDEX8, GL_DEPTH_BITS, GL_RGB8UI, +GL_STENCIL_BACK_REF, GL_INVALID_INDEX, GL_BLEND_DST_RGB, GL_SAMPLER_2D_SHADOW, GL_TEXTURE_BINDING_2D_ARRAY, +GL_RG16F, GL_SAMPLER_CUBE, GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, GL_RG16I, +GL_PIXEL_PACK_BUFFER_BINDING, GL_STENCIL_ATTACHMENT, GL_SAMPLE_COVERAGE, GL_ANY_SAMPLES_PASSED_CONSERVATIVE, GL_DRAW_FRAMEBUFFER, +GL_RGB10_A2UI, GL_SAMPLES; + diff --git a/demos/external/sources/glad/gl/loader.d b/demos/external/sources/glad/gl/loader.d new file mode 100644 index 0000000..35eca05 --- /dev/null +++ b/demos/external/sources/glad/gl/loader.d @@ -0,0 +1,1323 @@ +module glad.gl.loader; + + +private import glad.gl.funcs; +private import glad.gl.ext; +private import glad.gl.enums; +private import glad.gl.types; +alias Loader = void* delegate(const(char)*); + +version(Windows) { + private import core.sys.windows.windows; +} else { + private import core.sys.posix.dlfcn; +} + +version(Windows) { + private __gshared HMODULE libGL; +} else { + private __gshared void* libGL; +} +extern(System) private @nogc alias gladGetProcAddressPtrType = void* function(const(char)*); +private __gshared gladGetProcAddressPtrType gladGetProcAddressPtr; + +private +bool open_gl() @nogc { + version(WebAssembly)return false; + else version(Windows) { + libGL = LoadLibraryA("opengl32.dll"); + if(libGL !is null) { + gladGetProcAddressPtr = cast(typeof(gladGetProcAddressPtr))GetProcAddress( + libGL, "wglGetProcAddress"); + return gladGetProcAddressPtr !is null; + } + + return false; + } else { + version(OSX) { + enum const(char)*[] NAMES = [ + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + ]; + } else { + enum const(char)*[] NAMES = ["libGL.so.1", "libGL.so"]; + } + + foreach(name; NAMES) { + libGL = dlopen(name, RTLD_NOW | RTLD_GLOBAL); + if(libGL !is null) { + version(OSX) { + return true; + } else { + gladGetProcAddressPtr = cast(typeof(gladGetProcAddressPtr))dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr !is null; + } + } + } + + return false; + } +} + +private +void* get_proc(const(char)* namez) @nogc { + if(libGL is null) return null; + void* result; + + if(gladGetProcAddressPtr !is null) { + result = gladGetProcAddressPtr(namez); + } + if(result is null) { + version(WebAssembly)return result; + else version(Windows) { + result = GetProcAddress(libGL, namez); + } else { + result = dlsym(libGL, namez); + } + } + + return result; +} + +private +void close_gl() @nogc { + version(WebAssembly){} + else version(Windows) { + if(libGL !is null) { + FreeLibrary(libGL); + libGL = null; + } + } else { + if(libGL !is null) { + dlclose(libGL); + libGL = null; + } + } +} + +bool gladLoadGL() { + bool status = false; + + if(open_gl()) { + status = gladLoadGL(x => get_proc(x)); + close_gl(); + } + + return status; +} + +static struct GLVersion { static int major = 0; static int minor = 0; } +private extern(C) char* strstr(const(char)*, const(char)*) @nogc; +private extern(C) int strcmp(const(char)*, const(char)*) @nogc; +private extern(C) int strncmp(const(char)*, const(char)*, size_t) @nogc; +private extern(C) size_t strlen(const(char)*) @nogc; +private bool has_ext(const(char)* ext) @nogc { + if(GLVersion.major < 3) { + const(char)* extensions = cast(const(char)*)glGetString(GL_EXTENSIONS); + const(char)* loc; + const(char)* terminator; + + if(extensions is null || ext is null) { + return false; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc is null) { + return false; + } + + terminator = loc + strlen(ext); + if((loc is extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return true; + } + extensions = terminator; + } + } else { + int num; + glGetIntegerv(GL_NUM_EXTENSIONS, &num); + + for(uint i=0; i < cast(uint)num; i++) { + if(strcmp(cast(const(char)*)glGetStringi(GL_EXTENSIONS, i), ext) == 0) { + return true; + } + } + } + + return false; +} +bool gladLoadGL(Loader load) { + glGetString = cast(typeof(glGetString))load("glGetString"); + if(glGetString is null) { return false; } + if(glGetString(GL_VERSION) is null) { return false; } + + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + find_extensionsGL(); + return GLVersion.major != 0 || GLVersion.minor != 0; +} + +private { + +void find_coreGL() { + + // Thank you @elmindreda + // https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + // https://github.com/glfw/glfw/blob/master/src/context.c#L36 + int i; + const(char)* glversion; + const(char)*[3] prefixes = [ + "OpenGL ES-CM ".ptr, + "OpenGL ES-CL ".ptr, + "OpenGL ES ".ptr, + ]; + + glversion = cast(const(char)*)glGetString(GL_VERSION); + if (glversion is null) return; + + foreach(prefix; prefixes) { + size_t length = strlen(prefix); + if (strncmp(glversion, prefix, length) == 0) { + glversion += length; + break; + } + } + + int major = glversion[0] - '0'; + int minor = glversion[2] - '0'; + GLVersion.major = major; GLVersion.minor = minor; + GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + return; +} + +void find_extensionsGL() { + return; +} + +void load_GL_VERSION_1_0(Loader load) { + if(!GL_VERSION_1_0) return; + glCullFace = cast(typeof(glCullFace))load("glCullFace"); + glFrontFace = cast(typeof(glFrontFace))load("glFrontFace"); + glHint = cast(typeof(glHint))load("glHint"); + glLineWidth = cast(typeof(glLineWidth))load("glLineWidth"); + glPointSize = cast(typeof(glPointSize))load("glPointSize"); + glPolygonMode = cast(typeof(glPolygonMode))load("glPolygonMode"); + glScissor = cast(typeof(glScissor))load("glScissor"); + glTexParameterf = cast(typeof(glTexParameterf))load("glTexParameterf"); + glTexParameterfv = cast(typeof(glTexParameterfv))load("glTexParameterfv"); + glTexParameteri = cast(typeof(glTexParameteri))load("glTexParameteri"); + glTexParameteriv = cast(typeof(glTexParameteriv))load("glTexParameteriv"); + glTexImage1D = cast(typeof(glTexImage1D))load("glTexImage1D"); + glTexImage2D = cast(typeof(glTexImage2D))load("glTexImage2D"); + glDrawBuffer = cast(typeof(glDrawBuffer))load("glDrawBuffer"); + glClear = cast(typeof(glClear))load("glClear"); + glClearColor = cast(typeof(glClearColor))load("glClearColor"); + glClearStencil = cast(typeof(glClearStencil))load("glClearStencil"); + glClearDepth = cast(typeof(glClearDepth))load("glClearDepth"); + glStencilMask = cast(typeof(glStencilMask))load("glStencilMask"); + glColorMask = cast(typeof(glColorMask))load("glColorMask"); + glDepthMask = cast(typeof(glDepthMask))load("glDepthMask"); + glDisable = cast(typeof(glDisable))load("glDisable"); + glEnable = cast(typeof(glEnable))load("glEnable"); + glFinish = cast(typeof(glFinish))load("glFinish"); + glFlush = cast(typeof(glFlush))load("glFlush"); + glBlendFunc = cast(typeof(glBlendFunc))load("glBlendFunc"); + glLogicOp = cast(typeof(glLogicOp))load("glLogicOp"); + glStencilFunc = cast(typeof(glStencilFunc))load("glStencilFunc"); + glStencilOp = cast(typeof(glStencilOp))load("glStencilOp"); + glDepthFunc = cast(typeof(glDepthFunc))load("glDepthFunc"); + glPixelStoref = cast(typeof(glPixelStoref))load("glPixelStoref"); + glPixelStorei = cast(typeof(glPixelStorei))load("glPixelStorei"); + glReadBuffer = cast(typeof(glReadBuffer))load("glReadBuffer"); + glReadPixels = cast(typeof(glReadPixels))load("glReadPixels"); + glGetBooleanv = cast(typeof(glGetBooleanv))load("glGetBooleanv"); + glGetDoublev = cast(typeof(glGetDoublev))load("glGetDoublev"); + glGetError = cast(typeof(glGetError))load("glGetError"); + glGetFloatv = cast(typeof(glGetFloatv))load("glGetFloatv"); + glGetIntegerv = cast(typeof(glGetIntegerv))load("glGetIntegerv"); + glGetString = cast(typeof(glGetString))load("glGetString"); + glGetTexImage = cast(typeof(glGetTexImage))load("glGetTexImage"); + glGetTexParameterfv = cast(typeof(glGetTexParameterfv))load("glGetTexParameterfv"); + glGetTexParameteriv = cast(typeof(glGetTexParameteriv))load("glGetTexParameteriv"); + glGetTexLevelParameterfv = cast(typeof(glGetTexLevelParameterfv))load("glGetTexLevelParameterfv"); + glGetTexLevelParameteriv = cast(typeof(glGetTexLevelParameteriv))load("glGetTexLevelParameteriv"); + glIsEnabled = cast(typeof(glIsEnabled))load("glIsEnabled"); + glDepthRange = cast(typeof(glDepthRange))load("glDepthRange"); + glViewport = cast(typeof(glViewport))load("glViewport"); + glNewList = cast(typeof(glNewList))load("glNewList"); + glEndList = cast(typeof(glEndList))load("glEndList"); + glCallList = cast(typeof(glCallList))load("glCallList"); + glCallLists = cast(typeof(glCallLists))load("glCallLists"); + glDeleteLists = cast(typeof(glDeleteLists))load("glDeleteLists"); + glGenLists = cast(typeof(glGenLists))load("glGenLists"); + glListBase = cast(typeof(glListBase))load("glListBase"); + glBegin = cast(typeof(glBegin))load("glBegin"); + glBitmap = cast(typeof(glBitmap))load("glBitmap"); + glColor3b = cast(typeof(glColor3b))load("glColor3b"); + glColor3bv = cast(typeof(glColor3bv))load("glColor3bv"); + glColor3d = cast(typeof(glColor3d))load("glColor3d"); + glColor3dv = cast(typeof(glColor3dv))load("glColor3dv"); + glColor3f = cast(typeof(glColor3f))load("glColor3f"); + glColor3fv = cast(typeof(glColor3fv))load("glColor3fv"); + glColor3i = cast(typeof(glColor3i))load("glColor3i"); + glColor3iv = cast(typeof(glColor3iv))load("glColor3iv"); + glColor3s = cast(typeof(glColor3s))load("glColor3s"); + glColor3sv = cast(typeof(glColor3sv))load("glColor3sv"); + glColor3ub = cast(typeof(glColor3ub))load("glColor3ub"); + glColor3ubv = cast(typeof(glColor3ubv))load("glColor3ubv"); + glColor3ui = cast(typeof(glColor3ui))load("glColor3ui"); + glColor3uiv = cast(typeof(glColor3uiv))load("glColor3uiv"); + glColor3us = cast(typeof(glColor3us))load("glColor3us"); + glColor3usv = cast(typeof(glColor3usv))load("glColor3usv"); + glColor4b = cast(typeof(glColor4b))load("glColor4b"); + glColor4bv = cast(typeof(glColor4bv))load("glColor4bv"); + glColor4d = cast(typeof(glColor4d))load("glColor4d"); + glColor4dv = cast(typeof(glColor4dv))load("glColor4dv"); + glColor4f = cast(typeof(glColor4f))load("glColor4f"); + glColor4fv = cast(typeof(glColor4fv))load("glColor4fv"); + glColor4i = cast(typeof(glColor4i))load("glColor4i"); + glColor4iv = cast(typeof(glColor4iv))load("glColor4iv"); + glColor4s = cast(typeof(glColor4s))load("glColor4s"); + glColor4sv = cast(typeof(glColor4sv))load("glColor4sv"); + glColor4ub = cast(typeof(glColor4ub))load("glColor4ub"); + glColor4ubv = cast(typeof(glColor4ubv))load("glColor4ubv"); + glColor4ui = cast(typeof(glColor4ui))load("glColor4ui"); + glColor4uiv = cast(typeof(glColor4uiv))load("glColor4uiv"); + glColor4us = cast(typeof(glColor4us))load("glColor4us"); + glColor4usv = cast(typeof(glColor4usv))load("glColor4usv"); + glEdgeFlag = cast(typeof(glEdgeFlag))load("glEdgeFlag"); + glEdgeFlagv = cast(typeof(glEdgeFlagv))load("glEdgeFlagv"); + glEnd = cast(typeof(glEnd))load("glEnd"); + glIndexd = cast(typeof(glIndexd))load("glIndexd"); + glIndexdv = cast(typeof(glIndexdv))load("glIndexdv"); + glIndexf = cast(typeof(glIndexf))load("glIndexf"); + glIndexfv = cast(typeof(glIndexfv))load("glIndexfv"); + glIndexi = cast(typeof(glIndexi))load("glIndexi"); + glIndexiv = cast(typeof(glIndexiv))load("glIndexiv"); + glIndexs = cast(typeof(glIndexs))load("glIndexs"); + glIndexsv = cast(typeof(glIndexsv))load("glIndexsv"); + glNormal3b = cast(typeof(glNormal3b))load("glNormal3b"); + glNormal3bv = cast(typeof(glNormal3bv))load("glNormal3bv"); + glNormal3d = cast(typeof(glNormal3d))load("glNormal3d"); + glNormal3dv = cast(typeof(glNormal3dv))load("glNormal3dv"); + glNormal3f = cast(typeof(glNormal3f))load("glNormal3f"); + glNormal3fv = cast(typeof(glNormal3fv))load("glNormal3fv"); + glNormal3i = cast(typeof(glNormal3i))load("glNormal3i"); + glNormal3iv = cast(typeof(glNormal3iv))load("glNormal3iv"); + glNormal3s = cast(typeof(glNormal3s))load("glNormal3s"); + glNormal3sv = cast(typeof(glNormal3sv))load("glNormal3sv"); + glRasterPos2d = cast(typeof(glRasterPos2d))load("glRasterPos2d"); + glRasterPos2dv = cast(typeof(glRasterPos2dv))load("glRasterPos2dv"); + glRasterPos2f = cast(typeof(glRasterPos2f))load("glRasterPos2f"); + glRasterPos2fv = cast(typeof(glRasterPos2fv))load("glRasterPos2fv"); + glRasterPos2i = cast(typeof(glRasterPos2i))load("glRasterPos2i"); + glRasterPos2iv = cast(typeof(glRasterPos2iv))load("glRasterPos2iv"); + glRasterPos2s = cast(typeof(glRasterPos2s))load("glRasterPos2s"); + glRasterPos2sv = cast(typeof(glRasterPos2sv))load("glRasterPos2sv"); + glRasterPos3d = cast(typeof(glRasterPos3d))load("glRasterPos3d"); + glRasterPos3dv = cast(typeof(glRasterPos3dv))load("glRasterPos3dv"); + glRasterPos3f = cast(typeof(glRasterPos3f))load("glRasterPos3f"); + glRasterPos3fv = cast(typeof(glRasterPos3fv))load("glRasterPos3fv"); + glRasterPos3i = cast(typeof(glRasterPos3i))load("glRasterPos3i"); + glRasterPos3iv = cast(typeof(glRasterPos3iv))load("glRasterPos3iv"); + glRasterPos3s = cast(typeof(glRasterPos3s))load("glRasterPos3s"); + glRasterPos3sv = cast(typeof(glRasterPos3sv))load("glRasterPos3sv"); + glRasterPos4d = cast(typeof(glRasterPos4d))load("glRasterPos4d"); + glRasterPos4dv = cast(typeof(glRasterPos4dv))load("glRasterPos4dv"); + glRasterPos4f = cast(typeof(glRasterPos4f))load("glRasterPos4f"); + glRasterPos4fv = cast(typeof(glRasterPos4fv))load("glRasterPos4fv"); + glRasterPos4i = cast(typeof(glRasterPos4i))load("glRasterPos4i"); + glRasterPos4iv = cast(typeof(glRasterPos4iv))load("glRasterPos4iv"); + glRasterPos4s = cast(typeof(glRasterPos4s))load("glRasterPos4s"); + glRasterPos4sv = cast(typeof(glRasterPos4sv))load("glRasterPos4sv"); + glRectd = cast(typeof(glRectd))load("glRectd"); + glRectdv = cast(typeof(glRectdv))load("glRectdv"); + glRectf = cast(typeof(glRectf))load("glRectf"); + glRectfv = cast(typeof(glRectfv))load("glRectfv"); + glRecti = cast(typeof(glRecti))load("glRecti"); + glRectiv = cast(typeof(glRectiv))load("glRectiv"); + glRects = cast(typeof(glRects))load("glRects"); + glRectsv = cast(typeof(glRectsv))load("glRectsv"); + glTexCoord1d = cast(typeof(glTexCoord1d))load("glTexCoord1d"); + glTexCoord1dv = cast(typeof(glTexCoord1dv))load("glTexCoord1dv"); + glTexCoord1f = cast(typeof(glTexCoord1f))load("glTexCoord1f"); + glTexCoord1fv = cast(typeof(glTexCoord1fv))load("glTexCoord1fv"); + glTexCoord1i = cast(typeof(glTexCoord1i))load("glTexCoord1i"); + glTexCoord1iv = cast(typeof(glTexCoord1iv))load("glTexCoord1iv"); + glTexCoord1s = cast(typeof(glTexCoord1s))load("glTexCoord1s"); + glTexCoord1sv = cast(typeof(glTexCoord1sv))load("glTexCoord1sv"); + glTexCoord2d = cast(typeof(glTexCoord2d))load("glTexCoord2d"); + glTexCoord2dv = cast(typeof(glTexCoord2dv))load("glTexCoord2dv"); + glTexCoord2f = cast(typeof(glTexCoord2f))load("glTexCoord2f"); + glTexCoord2fv = cast(typeof(glTexCoord2fv))load("glTexCoord2fv"); + glTexCoord2i = cast(typeof(glTexCoord2i))load("glTexCoord2i"); + glTexCoord2iv = cast(typeof(glTexCoord2iv))load("glTexCoord2iv"); + glTexCoord2s = cast(typeof(glTexCoord2s))load("glTexCoord2s"); + glTexCoord2sv = cast(typeof(glTexCoord2sv))load("glTexCoord2sv"); + glTexCoord3d = cast(typeof(glTexCoord3d))load("glTexCoord3d"); + glTexCoord3dv = cast(typeof(glTexCoord3dv))load("glTexCoord3dv"); + glTexCoord3f = cast(typeof(glTexCoord3f))load("glTexCoord3f"); + glTexCoord3fv = cast(typeof(glTexCoord3fv))load("glTexCoord3fv"); + glTexCoord3i = cast(typeof(glTexCoord3i))load("glTexCoord3i"); + glTexCoord3iv = cast(typeof(glTexCoord3iv))load("glTexCoord3iv"); + glTexCoord3s = cast(typeof(glTexCoord3s))load("glTexCoord3s"); + glTexCoord3sv = cast(typeof(glTexCoord3sv))load("glTexCoord3sv"); + glTexCoord4d = cast(typeof(glTexCoord4d))load("glTexCoord4d"); + glTexCoord4dv = cast(typeof(glTexCoord4dv))load("glTexCoord4dv"); + glTexCoord4f = cast(typeof(glTexCoord4f))load("glTexCoord4f"); + glTexCoord4fv = cast(typeof(glTexCoord4fv))load("glTexCoord4fv"); + glTexCoord4i = cast(typeof(glTexCoord4i))load("glTexCoord4i"); + glTexCoord4iv = cast(typeof(glTexCoord4iv))load("glTexCoord4iv"); + glTexCoord4s = cast(typeof(glTexCoord4s))load("glTexCoord4s"); + glTexCoord4sv = cast(typeof(glTexCoord4sv))load("glTexCoord4sv"); + glVertex2d = cast(typeof(glVertex2d))load("glVertex2d"); + glVertex2dv = cast(typeof(glVertex2dv))load("glVertex2dv"); + glVertex2f = cast(typeof(glVertex2f))load("glVertex2f"); + glVertex2fv = cast(typeof(glVertex2fv))load("glVertex2fv"); + glVertex2i = cast(typeof(glVertex2i))load("glVertex2i"); + glVertex2iv = cast(typeof(glVertex2iv))load("glVertex2iv"); + glVertex2s = cast(typeof(glVertex2s))load("glVertex2s"); + glVertex2sv = cast(typeof(glVertex2sv))load("glVertex2sv"); + glVertex3d = cast(typeof(glVertex3d))load("glVertex3d"); + glVertex3dv = cast(typeof(glVertex3dv))load("glVertex3dv"); + glVertex3f = cast(typeof(glVertex3f))load("glVertex3f"); + glVertex3fv = cast(typeof(glVertex3fv))load("glVertex3fv"); + glVertex3i = cast(typeof(glVertex3i))load("glVertex3i"); + glVertex3iv = cast(typeof(glVertex3iv))load("glVertex3iv"); + glVertex3s = cast(typeof(glVertex3s))load("glVertex3s"); + glVertex3sv = cast(typeof(glVertex3sv))load("glVertex3sv"); + glVertex4d = cast(typeof(glVertex4d))load("glVertex4d"); + glVertex4dv = cast(typeof(glVertex4dv))load("glVertex4dv"); + glVertex4f = cast(typeof(glVertex4f))load("glVertex4f"); + glVertex4fv = cast(typeof(glVertex4fv))load("glVertex4fv"); + glVertex4i = cast(typeof(glVertex4i))load("glVertex4i"); + glVertex4iv = cast(typeof(glVertex4iv))load("glVertex4iv"); + glVertex4s = cast(typeof(glVertex4s))load("glVertex4s"); + glVertex4sv = cast(typeof(glVertex4sv))load("glVertex4sv"); + glClipPlane = cast(typeof(glClipPlane))load("glClipPlane"); + glColorMaterial = cast(typeof(glColorMaterial))load("glColorMaterial"); + glFogf = cast(typeof(glFogf))load("glFogf"); + glFogfv = cast(typeof(glFogfv))load("glFogfv"); + glFogi = cast(typeof(glFogi))load("glFogi"); + glFogiv = cast(typeof(glFogiv))load("glFogiv"); + glLightf = cast(typeof(glLightf))load("glLightf"); + glLightfv = cast(typeof(glLightfv))load("glLightfv"); + glLighti = cast(typeof(glLighti))load("glLighti"); + glLightiv = cast(typeof(glLightiv))load("glLightiv"); + glLightModelf = cast(typeof(glLightModelf))load("glLightModelf"); + glLightModelfv = cast(typeof(glLightModelfv))load("glLightModelfv"); + glLightModeli = cast(typeof(glLightModeli))load("glLightModeli"); + glLightModeliv = cast(typeof(glLightModeliv))load("glLightModeliv"); + glLineStipple = cast(typeof(glLineStipple))load("glLineStipple"); + glMaterialf = cast(typeof(glMaterialf))load("glMaterialf"); + glMaterialfv = cast(typeof(glMaterialfv))load("glMaterialfv"); + glMateriali = cast(typeof(glMateriali))load("glMateriali"); + glMaterialiv = cast(typeof(glMaterialiv))load("glMaterialiv"); + glPolygonStipple = cast(typeof(glPolygonStipple))load("glPolygonStipple"); + glShadeModel = cast(typeof(glShadeModel))load("glShadeModel"); + glTexEnvf = cast(typeof(glTexEnvf))load("glTexEnvf"); + glTexEnvfv = cast(typeof(glTexEnvfv))load("glTexEnvfv"); + glTexEnvi = cast(typeof(glTexEnvi))load("glTexEnvi"); + glTexEnviv = cast(typeof(glTexEnviv))load("glTexEnviv"); + glTexGend = cast(typeof(glTexGend))load("glTexGend"); + glTexGendv = cast(typeof(glTexGendv))load("glTexGendv"); + glTexGenf = cast(typeof(glTexGenf))load("glTexGenf"); + glTexGenfv = cast(typeof(glTexGenfv))load("glTexGenfv"); + glTexGeni = cast(typeof(glTexGeni))load("glTexGeni"); + glTexGeniv = cast(typeof(glTexGeniv))load("glTexGeniv"); + glFeedbackBuffer = cast(typeof(glFeedbackBuffer))load("glFeedbackBuffer"); + glSelectBuffer = cast(typeof(glSelectBuffer))load("glSelectBuffer"); + glRenderMode = cast(typeof(glRenderMode))load("glRenderMode"); + glInitNames = cast(typeof(glInitNames))load("glInitNames"); + glLoadName = cast(typeof(glLoadName))load("glLoadName"); + glPassThrough = cast(typeof(glPassThrough))load("glPassThrough"); + glPopName = cast(typeof(glPopName))load("glPopName"); + glPushName = cast(typeof(glPushName))load("glPushName"); + glClearAccum = cast(typeof(glClearAccum))load("glClearAccum"); + glClearIndex = cast(typeof(glClearIndex))load("glClearIndex"); + glIndexMask = cast(typeof(glIndexMask))load("glIndexMask"); + glAccum = cast(typeof(glAccum))load("glAccum"); + glPopAttrib = cast(typeof(glPopAttrib))load("glPopAttrib"); + glPushAttrib = cast(typeof(glPushAttrib))load("glPushAttrib"); + glMap1d = cast(typeof(glMap1d))load("glMap1d"); + glMap1f = cast(typeof(glMap1f))load("glMap1f"); + glMap2d = cast(typeof(glMap2d))load("glMap2d"); + glMap2f = cast(typeof(glMap2f))load("glMap2f"); + glMapGrid1d = cast(typeof(glMapGrid1d))load("glMapGrid1d"); + glMapGrid1f = cast(typeof(glMapGrid1f))load("glMapGrid1f"); + glMapGrid2d = cast(typeof(glMapGrid2d))load("glMapGrid2d"); + glMapGrid2f = cast(typeof(glMapGrid2f))load("glMapGrid2f"); + glEvalCoord1d = cast(typeof(glEvalCoord1d))load("glEvalCoord1d"); + glEvalCoord1dv = cast(typeof(glEvalCoord1dv))load("glEvalCoord1dv"); + glEvalCoord1f = cast(typeof(glEvalCoord1f))load("glEvalCoord1f"); + glEvalCoord1fv = cast(typeof(glEvalCoord1fv))load("glEvalCoord1fv"); + glEvalCoord2d = cast(typeof(glEvalCoord2d))load("glEvalCoord2d"); + glEvalCoord2dv = cast(typeof(glEvalCoord2dv))load("glEvalCoord2dv"); + glEvalCoord2f = cast(typeof(glEvalCoord2f))load("glEvalCoord2f"); + glEvalCoord2fv = cast(typeof(glEvalCoord2fv))load("glEvalCoord2fv"); + glEvalMesh1 = cast(typeof(glEvalMesh1))load("glEvalMesh1"); + glEvalPoint1 = cast(typeof(glEvalPoint1))load("glEvalPoint1"); + glEvalMesh2 = cast(typeof(glEvalMesh2))load("glEvalMesh2"); + glEvalPoint2 = cast(typeof(glEvalPoint2))load("glEvalPoint2"); + glAlphaFunc = cast(typeof(glAlphaFunc))load("glAlphaFunc"); + glPixelZoom = cast(typeof(glPixelZoom))load("glPixelZoom"); + glPixelTransferf = cast(typeof(glPixelTransferf))load("glPixelTransferf"); + glPixelTransferi = cast(typeof(glPixelTransferi))load("glPixelTransferi"); + glPixelMapfv = cast(typeof(glPixelMapfv))load("glPixelMapfv"); + glPixelMapuiv = cast(typeof(glPixelMapuiv))load("glPixelMapuiv"); + glPixelMapusv = cast(typeof(glPixelMapusv))load("glPixelMapusv"); + glCopyPixels = cast(typeof(glCopyPixels))load("glCopyPixels"); + glDrawPixels = cast(typeof(glDrawPixels))load("glDrawPixels"); + glGetClipPlane = cast(typeof(glGetClipPlane))load("glGetClipPlane"); + glGetLightfv = cast(typeof(glGetLightfv))load("glGetLightfv"); + glGetLightiv = cast(typeof(glGetLightiv))load("glGetLightiv"); + glGetMapdv = cast(typeof(glGetMapdv))load("glGetMapdv"); + glGetMapfv = cast(typeof(glGetMapfv))load("glGetMapfv"); + glGetMapiv = cast(typeof(glGetMapiv))load("glGetMapiv"); + glGetMaterialfv = cast(typeof(glGetMaterialfv))load("glGetMaterialfv"); + glGetMaterialiv = cast(typeof(glGetMaterialiv))load("glGetMaterialiv"); + glGetPixelMapfv = cast(typeof(glGetPixelMapfv))load("glGetPixelMapfv"); + glGetPixelMapuiv = cast(typeof(glGetPixelMapuiv))load("glGetPixelMapuiv"); + glGetPixelMapusv = cast(typeof(glGetPixelMapusv))load("glGetPixelMapusv"); + glGetPolygonStipple = cast(typeof(glGetPolygonStipple))load("glGetPolygonStipple"); + glGetTexEnvfv = cast(typeof(glGetTexEnvfv))load("glGetTexEnvfv"); + glGetTexEnviv = cast(typeof(glGetTexEnviv))load("glGetTexEnviv"); + glGetTexGendv = cast(typeof(glGetTexGendv))load("glGetTexGendv"); + glGetTexGenfv = cast(typeof(glGetTexGenfv))load("glGetTexGenfv"); + glGetTexGeniv = cast(typeof(glGetTexGeniv))load("glGetTexGeniv"); + glIsList = cast(typeof(glIsList))load("glIsList"); + glFrustum = cast(typeof(glFrustum))load("glFrustum"); + glLoadIdentity = cast(typeof(glLoadIdentity))load("glLoadIdentity"); + glLoadMatrixf = cast(typeof(glLoadMatrixf))load("glLoadMatrixf"); + glLoadMatrixd = cast(typeof(glLoadMatrixd))load("glLoadMatrixd"); + glMatrixMode = cast(typeof(glMatrixMode))load("glMatrixMode"); + glMultMatrixf = cast(typeof(glMultMatrixf))load("glMultMatrixf"); + glMultMatrixd = cast(typeof(glMultMatrixd))load("glMultMatrixd"); + glOrtho = cast(typeof(glOrtho))load("glOrtho"); + glPopMatrix = cast(typeof(glPopMatrix))load("glPopMatrix"); + glPushMatrix = cast(typeof(glPushMatrix))load("glPushMatrix"); + glRotated = cast(typeof(glRotated))load("glRotated"); + glRotatef = cast(typeof(glRotatef))load("glRotatef"); + glScaled = cast(typeof(glScaled))load("glScaled"); + glScalef = cast(typeof(glScalef))load("glScalef"); + glTranslated = cast(typeof(glTranslated))load("glTranslated"); + glTranslatef = cast(typeof(glTranslatef))load("glTranslatef"); + return; +} + +void load_GL_VERSION_1_1(Loader load) { + if(!GL_VERSION_1_1) return; + glDrawArrays = cast(typeof(glDrawArrays))load("glDrawArrays"); + glDrawElements = cast(typeof(glDrawElements))load("glDrawElements"); + glGetPointerv = cast(typeof(glGetPointerv))load("glGetPointerv"); + glPolygonOffset = cast(typeof(glPolygonOffset))load("glPolygonOffset"); + glCopyTexImage1D = cast(typeof(glCopyTexImage1D))load("glCopyTexImage1D"); + glCopyTexImage2D = cast(typeof(glCopyTexImage2D))load("glCopyTexImage2D"); + glCopyTexSubImage1D = cast(typeof(glCopyTexSubImage1D))load("glCopyTexSubImage1D"); + glCopyTexSubImage2D = cast(typeof(glCopyTexSubImage2D))load("glCopyTexSubImage2D"); + glTexSubImage1D = cast(typeof(glTexSubImage1D))load("glTexSubImage1D"); + glTexSubImage2D = cast(typeof(glTexSubImage2D))load("glTexSubImage2D"); + glBindTexture = cast(typeof(glBindTexture))load("glBindTexture"); + glDeleteTextures = cast(typeof(glDeleteTextures))load("glDeleteTextures"); + glGenTextures = cast(typeof(glGenTextures))load("glGenTextures"); + glIsTexture = cast(typeof(glIsTexture))load("glIsTexture"); + glArrayElement = cast(typeof(glArrayElement))load("glArrayElement"); + glColorPointer = cast(typeof(glColorPointer))load("glColorPointer"); + glDisableClientState = cast(typeof(glDisableClientState))load("glDisableClientState"); + glEdgeFlagPointer = cast(typeof(glEdgeFlagPointer))load("glEdgeFlagPointer"); + glEnableClientState = cast(typeof(glEnableClientState))load("glEnableClientState"); + glIndexPointer = cast(typeof(glIndexPointer))load("glIndexPointer"); + glInterleavedArrays = cast(typeof(glInterleavedArrays))load("glInterleavedArrays"); + glNormalPointer = cast(typeof(glNormalPointer))load("glNormalPointer"); + glTexCoordPointer = cast(typeof(glTexCoordPointer))load("glTexCoordPointer"); + glVertexPointer = cast(typeof(glVertexPointer))load("glVertexPointer"); + glAreTexturesResident = cast(typeof(glAreTexturesResident))load("glAreTexturesResident"); + glPrioritizeTextures = cast(typeof(glPrioritizeTextures))load("glPrioritizeTextures"); + glIndexub = cast(typeof(glIndexub))load("glIndexub"); + glIndexubv = cast(typeof(glIndexubv))load("glIndexubv"); + glPopClientAttrib = cast(typeof(glPopClientAttrib))load("glPopClientAttrib"); + glPushClientAttrib = cast(typeof(glPushClientAttrib))load("glPushClientAttrib"); + return; +} + +void load_GL_VERSION_1_2(Loader load) { + if(!GL_VERSION_1_2) return; + glDrawRangeElements = cast(typeof(glDrawRangeElements))load("glDrawRangeElements"); + glTexImage3D = cast(typeof(glTexImage3D))load("glTexImage3D"); + glTexSubImage3D = cast(typeof(glTexSubImage3D))load("glTexSubImage3D"); + glCopyTexSubImage3D = cast(typeof(glCopyTexSubImage3D))load("glCopyTexSubImage3D"); + return; +} + +void load_GL_VERSION_1_3(Loader load) { + if(!GL_VERSION_1_3) return; + glActiveTexture = cast(typeof(glActiveTexture))load("glActiveTexture"); + glSampleCoverage = cast(typeof(glSampleCoverage))load("glSampleCoverage"); + glCompressedTexImage3D = cast(typeof(glCompressedTexImage3D))load("glCompressedTexImage3D"); + glCompressedTexImage2D = cast(typeof(glCompressedTexImage2D))load("glCompressedTexImage2D"); + glCompressedTexImage1D = cast(typeof(glCompressedTexImage1D))load("glCompressedTexImage1D"); + glCompressedTexSubImage3D = cast(typeof(glCompressedTexSubImage3D))load("glCompressedTexSubImage3D"); + glCompressedTexSubImage2D = cast(typeof(glCompressedTexSubImage2D))load("glCompressedTexSubImage2D"); + glCompressedTexSubImage1D = cast(typeof(glCompressedTexSubImage1D))load("glCompressedTexSubImage1D"); + glGetCompressedTexImage = cast(typeof(glGetCompressedTexImage))load("glGetCompressedTexImage"); + glClientActiveTexture = cast(typeof(glClientActiveTexture))load("glClientActiveTexture"); + glMultiTexCoord1d = cast(typeof(glMultiTexCoord1d))load("glMultiTexCoord1d"); + glMultiTexCoord1dv = cast(typeof(glMultiTexCoord1dv))load("glMultiTexCoord1dv"); + glMultiTexCoord1f = cast(typeof(glMultiTexCoord1f))load("glMultiTexCoord1f"); + glMultiTexCoord1fv = cast(typeof(glMultiTexCoord1fv))load("glMultiTexCoord1fv"); + glMultiTexCoord1i = cast(typeof(glMultiTexCoord1i))load("glMultiTexCoord1i"); + glMultiTexCoord1iv = cast(typeof(glMultiTexCoord1iv))load("glMultiTexCoord1iv"); + glMultiTexCoord1s = cast(typeof(glMultiTexCoord1s))load("glMultiTexCoord1s"); + glMultiTexCoord1sv = cast(typeof(glMultiTexCoord1sv))load("glMultiTexCoord1sv"); + glMultiTexCoord2d = cast(typeof(glMultiTexCoord2d))load("glMultiTexCoord2d"); + glMultiTexCoord2dv = cast(typeof(glMultiTexCoord2dv))load("glMultiTexCoord2dv"); + glMultiTexCoord2f = cast(typeof(glMultiTexCoord2f))load("glMultiTexCoord2f"); + glMultiTexCoord2fv = cast(typeof(glMultiTexCoord2fv))load("glMultiTexCoord2fv"); + glMultiTexCoord2i = cast(typeof(glMultiTexCoord2i))load("glMultiTexCoord2i"); + glMultiTexCoord2iv = cast(typeof(glMultiTexCoord2iv))load("glMultiTexCoord2iv"); + glMultiTexCoord2s = cast(typeof(glMultiTexCoord2s))load("glMultiTexCoord2s"); + glMultiTexCoord2sv = cast(typeof(glMultiTexCoord2sv))load("glMultiTexCoord2sv"); + glMultiTexCoord3d = cast(typeof(glMultiTexCoord3d))load("glMultiTexCoord3d"); + glMultiTexCoord3dv = cast(typeof(glMultiTexCoord3dv))load("glMultiTexCoord3dv"); + glMultiTexCoord3f = cast(typeof(glMultiTexCoord3f))load("glMultiTexCoord3f"); + glMultiTexCoord3fv = cast(typeof(glMultiTexCoord3fv))load("glMultiTexCoord3fv"); + glMultiTexCoord3i = cast(typeof(glMultiTexCoord3i))load("glMultiTexCoord3i"); + glMultiTexCoord3iv = cast(typeof(glMultiTexCoord3iv))load("glMultiTexCoord3iv"); + glMultiTexCoord3s = cast(typeof(glMultiTexCoord3s))load("glMultiTexCoord3s"); + glMultiTexCoord3sv = cast(typeof(glMultiTexCoord3sv))load("glMultiTexCoord3sv"); + glMultiTexCoord4d = cast(typeof(glMultiTexCoord4d))load("glMultiTexCoord4d"); + glMultiTexCoord4dv = cast(typeof(glMultiTexCoord4dv))load("glMultiTexCoord4dv"); + glMultiTexCoord4f = cast(typeof(glMultiTexCoord4f))load("glMultiTexCoord4f"); + glMultiTexCoord4fv = cast(typeof(glMultiTexCoord4fv))load("glMultiTexCoord4fv"); + glMultiTexCoord4i = cast(typeof(glMultiTexCoord4i))load("glMultiTexCoord4i"); + glMultiTexCoord4iv = cast(typeof(glMultiTexCoord4iv))load("glMultiTexCoord4iv"); + glMultiTexCoord4s = cast(typeof(glMultiTexCoord4s))load("glMultiTexCoord4s"); + glMultiTexCoord4sv = cast(typeof(glMultiTexCoord4sv))load("glMultiTexCoord4sv"); + glLoadTransposeMatrixf = cast(typeof(glLoadTransposeMatrixf))load("glLoadTransposeMatrixf"); + glLoadTransposeMatrixd = cast(typeof(glLoadTransposeMatrixd))load("glLoadTransposeMatrixd"); + glMultTransposeMatrixf = cast(typeof(glMultTransposeMatrixf))load("glMultTransposeMatrixf"); + glMultTransposeMatrixd = cast(typeof(glMultTransposeMatrixd))load("glMultTransposeMatrixd"); + return; +} + +void load_GL_VERSION_1_4(Loader load) { + if(!GL_VERSION_1_4) return; + glBlendFuncSeparate = cast(typeof(glBlendFuncSeparate))load("glBlendFuncSeparate"); + glMultiDrawArrays = cast(typeof(glMultiDrawArrays))load("glMultiDrawArrays"); + glMultiDrawElements = cast(typeof(glMultiDrawElements))load("glMultiDrawElements"); + glPointParameterf = cast(typeof(glPointParameterf))load("glPointParameterf"); + glPointParameterfv = cast(typeof(glPointParameterfv))load("glPointParameterfv"); + glPointParameteri = cast(typeof(glPointParameteri))load("glPointParameteri"); + glPointParameteriv = cast(typeof(glPointParameteriv))load("glPointParameteriv"); + glFogCoordf = cast(typeof(glFogCoordf))load("glFogCoordf"); + glFogCoordfv = cast(typeof(glFogCoordfv))load("glFogCoordfv"); + glFogCoordd = cast(typeof(glFogCoordd))load("glFogCoordd"); + glFogCoorddv = cast(typeof(glFogCoorddv))load("glFogCoorddv"); + glFogCoordPointer = cast(typeof(glFogCoordPointer))load("glFogCoordPointer"); + glSecondaryColor3b = cast(typeof(glSecondaryColor3b))load("glSecondaryColor3b"); + glSecondaryColor3bv = cast(typeof(glSecondaryColor3bv))load("glSecondaryColor3bv"); + glSecondaryColor3d = cast(typeof(glSecondaryColor3d))load("glSecondaryColor3d"); + glSecondaryColor3dv = cast(typeof(glSecondaryColor3dv))load("glSecondaryColor3dv"); + glSecondaryColor3f = cast(typeof(glSecondaryColor3f))load("glSecondaryColor3f"); + glSecondaryColor3fv = cast(typeof(glSecondaryColor3fv))load("glSecondaryColor3fv"); + glSecondaryColor3i = cast(typeof(glSecondaryColor3i))load("glSecondaryColor3i"); + glSecondaryColor3iv = cast(typeof(glSecondaryColor3iv))load("glSecondaryColor3iv"); + glSecondaryColor3s = cast(typeof(glSecondaryColor3s))load("glSecondaryColor3s"); + glSecondaryColor3sv = cast(typeof(glSecondaryColor3sv))load("glSecondaryColor3sv"); + glSecondaryColor3ub = cast(typeof(glSecondaryColor3ub))load("glSecondaryColor3ub"); + glSecondaryColor3ubv = cast(typeof(glSecondaryColor3ubv))load("glSecondaryColor3ubv"); + glSecondaryColor3ui = cast(typeof(glSecondaryColor3ui))load("glSecondaryColor3ui"); + glSecondaryColor3uiv = cast(typeof(glSecondaryColor3uiv))load("glSecondaryColor3uiv"); + glSecondaryColor3us = cast(typeof(glSecondaryColor3us))load("glSecondaryColor3us"); + glSecondaryColor3usv = cast(typeof(glSecondaryColor3usv))load("glSecondaryColor3usv"); + glSecondaryColorPointer = cast(typeof(glSecondaryColorPointer))load("glSecondaryColorPointer"); + glWindowPos2d = cast(typeof(glWindowPos2d))load("glWindowPos2d"); + glWindowPos2dv = cast(typeof(glWindowPos2dv))load("glWindowPos2dv"); + glWindowPos2f = cast(typeof(glWindowPos2f))load("glWindowPos2f"); + glWindowPos2fv = cast(typeof(glWindowPos2fv))load("glWindowPos2fv"); + glWindowPos2i = cast(typeof(glWindowPos2i))load("glWindowPos2i"); + glWindowPos2iv = cast(typeof(glWindowPos2iv))load("glWindowPos2iv"); + glWindowPos2s = cast(typeof(glWindowPos2s))load("glWindowPos2s"); + glWindowPos2sv = cast(typeof(glWindowPos2sv))load("glWindowPos2sv"); + glWindowPos3d = cast(typeof(glWindowPos3d))load("glWindowPos3d"); + glWindowPos3dv = cast(typeof(glWindowPos3dv))load("glWindowPos3dv"); + glWindowPos3f = cast(typeof(glWindowPos3f))load("glWindowPos3f"); + glWindowPos3fv = cast(typeof(glWindowPos3fv))load("glWindowPos3fv"); + glWindowPos3i = cast(typeof(glWindowPos3i))load("glWindowPos3i"); + glWindowPos3iv = cast(typeof(glWindowPos3iv))load("glWindowPos3iv"); + glWindowPos3s = cast(typeof(glWindowPos3s))load("glWindowPos3s"); + glWindowPos3sv = cast(typeof(glWindowPos3sv))load("glWindowPos3sv"); + glBlendColor = cast(typeof(glBlendColor))load("glBlendColor"); + glBlendEquation = cast(typeof(glBlendEquation))load("glBlendEquation"); + return; +} + +void load_GL_VERSION_1_5(Loader load) { + if(!GL_VERSION_1_5) return; + glGenQueries = cast(typeof(glGenQueries))load("glGenQueries"); + glDeleteQueries = cast(typeof(glDeleteQueries))load("glDeleteQueries"); + glIsQuery = cast(typeof(glIsQuery))load("glIsQuery"); + glBeginQuery = cast(typeof(glBeginQuery))load("glBeginQuery"); + glEndQuery = cast(typeof(glEndQuery))load("glEndQuery"); + glGetQueryiv = cast(typeof(glGetQueryiv))load("glGetQueryiv"); + glGetQueryObjectiv = cast(typeof(glGetQueryObjectiv))load("glGetQueryObjectiv"); + glGetQueryObjectuiv = cast(typeof(glGetQueryObjectuiv))load("glGetQueryObjectuiv"); + glBindBuffer = cast(typeof(glBindBuffer))load("glBindBuffer"); + glDeleteBuffers = cast(typeof(glDeleteBuffers))load("glDeleteBuffers"); + glGenBuffers = cast(typeof(glGenBuffers))load("glGenBuffers"); + glIsBuffer = cast(typeof(glIsBuffer))load("glIsBuffer"); + glBufferData = cast(typeof(glBufferData))load("glBufferData"); + glBufferSubData = cast(typeof(glBufferSubData))load("glBufferSubData"); + glGetBufferSubData = cast(typeof(glGetBufferSubData))load("glGetBufferSubData"); + glMapBuffer = cast(typeof(glMapBuffer))load("glMapBuffer"); + glUnmapBuffer = cast(typeof(glUnmapBuffer))load("glUnmapBuffer"); + glGetBufferParameteriv = cast(typeof(glGetBufferParameteriv))load("glGetBufferParameteriv"); + glGetBufferPointerv = cast(typeof(glGetBufferPointerv))load("glGetBufferPointerv"); + return; +} + +void load_GL_VERSION_2_0(Loader load) { + if(!GL_VERSION_2_0) return; + glBlendEquationSeparate = cast(typeof(glBlendEquationSeparate))load("glBlendEquationSeparate"); + glDrawBuffers = cast(typeof(glDrawBuffers))load("glDrawBuffers"); + glStencilOpSeparate = cast(typeof(glStencilOpSeparate))load("glStencilOpSeparate"); + glStencilFuncSeparate = cast(typeof(glStencilFuncSeparate))load("glStencilFuncSeparate"); + glStencilMaskSeparate = cast(typeof(glStencilMaskSeparate))load("glStencilMaskSeparate"); + glAttachShader = cast(typeof(glAttachShader))load("glAttachShader"); + glBindAttribLocation = cast(typeof(glBindAttribLocation))load("glBindAttribLocation"); + glCompileShader = cast(typeof(glCompileShader))load("glCompileShader"); + glCreateProgram = cast(typeof(glCreateProgram))load("glCreateProgram"); + glCreateShader = cast(typeof(glCreateShader))load("glCreateShader"); + glDeleteProgram = cast(typeof(glDeleteProgram))load("glDeleteProgram"); + glDeleteShader = cast(typeof(glDeleteShader))load("glDeleteShader"); + glDetachShader = cast(typeof(glDetachShader))load("glDetachShader"); + glDisableVertexAttribArray = cast(typeof(glDisableVertexAttribArray))load("glDisableVertexAttribArray"); + glEnableVertexAttribArray = cast(typeof(glEnableVertexAttribArray))load("glEnableVertexAttribArray"); + glGetActiveAttrib = cast(typeof(glGetActiveAttrib))load("glGetActiveAttrib"); + glGetActiveUniform = cast(typeof(glGetActiveUniform))load("glGetActiveUniform"); + glGetAttachedShaders = cast(typeof(glGetAttachedShaders))load("glGetAttachedShaders"); + glGetAttribLocation = cast(typeof(glGetAttribLocation))load("glGetAttribLocation"); + glGetProgramiv = cast(typeof(glGetProgramiv))load("glGetProgramiv"); + glGetProgramInfoLog = cast(typeof(glGetProgramInfoLog))load("glGetProgramInfoLog"); + glGetShaderiv = cast(typeof(glGetShaderiv))load("glGetShaderiv"); + glGetShaderInfoLog = cast(typeof(glGetShaderInfoLog))load("glGetShaderInfoLog"); + glGetShaderSource = cast(typeof(glGetShaderSource))load("glGetShaderSource"); + glGetUniformLocation = cast(typeof(glGetUniformLocation))load("glGetUniformLocation"); + glGetUniformfv = cast(typeof(glGetUniformfv))load("glGetUniformfv"); + glGetUniformiv = cast(typeof(glGetUniformiv))load("glGetUniformiv"); + glGetVertexAttribdv = cast(typeof(glGetVertexAttribdv))load("glGetVertexAttribdv"); + glGetVertexAttribfv = cast(typeof(glGetVertexAttribfv))load("glGetVertexAttribfv"); + glGetVertexAttribiv = cast(typeof(glGetVertexAttribiv))load("glGetVertexAttribiv"); + glGetVertexAttribPointerv = cast(typeof(glGetVertexAttribPointerv))load("glGetVertexAttribPointerv"); + glIsProgram = cast(typeof(glIsProgram))load("glIsProgram"); + glIsShader = cast(typeof(glIsShader))load("glIsShader"); + glLinkProgram = cast(typeof(glLinkProgram))load("glLinkProgram"); + glShaderSource = cast(typeof(glShaderSource))load("glShaderSource"); + glUseProgram = cast(typeof(glUseProgram))load("glUseProgram"); + glUniform1f = cast(typeof(glUniform1f))load("glUniform1f"); + glUniform2f = cast(typeof(glUniform2f))load("glUniform2f"); + glUniform3f = cast(typeof(glUniform3f))load("glUniform3f"); + glUniform4f = cast(typeof(glUniform4f))load("glUniform4f"); + glUniform1i = cast(typeof(glUniform1i))load("glUniform1i"); + glUniform2i = cast(typeof(glUniform2i))load("glUniform2i"); + glUniform3i = cast(typeof(glUniform3i))load("glUniform3i"); + glUniform4i = cast(typeof(glUniform4i))load("glUniform4i"); + glUniform1fv = cast(typeof(glUniform1fv))load("glUniform1fv"); + glUniform2fv = cast(typeof(glUniform2fv))load("glUniform2fv"); + glUniform3fv = cast(typeof(glUniform3fv))load("glUniform3fv"); + glUniform4fv = cast(typeof(glUniform4fv))load("glUniform4fv"); + glUniform1iv = cast(typeof(glUniform1iv))load("glUniform1iv"); + glUniform2iv = cast(typeof(glUniform2iv))load("glUniform2iv"); + glUniform3iv = cast(typeof(glUniform3iv))load("glUniform3iv"); + glUniform4iv = cast(typeof(glUniform4iv))load("glUniform4iv"); + glUniformMatrix2fv = cast(typeof(glUniformMatrix2fv))load("glUniformMatrix2fv"); + glUniformMatrix3fv = cast(typeof(glUniformMatrix3fv))load("glUniformMatrix3fv"); + glUniformMatrix4fv = cast(typeof(glUniformMatrix4fv))load("glUniformMatrix4fv"); + glValidateProgram = cast(typeof(glValidateProgram))load("glValidateProgram"); + glVertexAttrib1d = cast(typeof(glVertexAttrib1d))load("glVertexAttrib1d"); + glVertexAttrib1dv = cast(typeof(glVertexAttrib1dv))load("glVertexAttrib1dv"); + glVertexAttrib1f = cast(typeof(glVertexAttrib1f))load("glVertexAttrib1f"); + glVertexAttrib1fv = cast(typeof(glVertexAttrib1fv))load("glVertexAttrib1fv"); + glVertexAttrib1s = cast(typeof(glVertexAttrib1s))load("glVertexAttrib1s"); + glVertexAttrib1sv = cast(typeof(glVertexAttrib1sv))load("glVertexAttrib1sv"); + glVertexAttrib2d = cast(typeof(glVertexAttrib2d))load("glVertexAttrib2d"); + glVertexAttrib2dv = cast(typeof(glVertexAttrib2dv))load("glVertexAttrib2dv"); + glVertexAttrib2f = cast(typeof(glVertexAttrib2f))load("glVertexAttrib2f"); + glVertexAttrib2fv = cast(typeof(glVertexAttrib2fv))load("glVertexAttrib2fv"); + glVertexAttrib2s = cast(typeof(glVertexAttrib2s))load("glVertexAttrib2s"); + glVertexAttrib2sv = cast(typeof(glVertexAttrib2sv))load("glVertexAttrib2sv"); + glVertexAttrib3d = cast(typeof(glVertexAttrib3d))load("glVertexAttrib3d"); + glVertexAttrib3dv = cast(typeof(glVertexAttrib3dv))load("glVertexAttrib3dv"); + glVertexAttrib3f = cast(typeof(glVertexAttrib3f))load("glVertexAttrib3f"); + glVertexAttrib3fv = cast(typeof(glVertexAttrib3fv))load("glVertexAttrib3fv"); + glVertexAttrib3s = cast(typeof(glVertexAttrib3s))load("glVertexAttrib3s"); + glVertexAttrib3sv = cast(typeof(glVertexAttrib3sv))load("glVertexAttrib3sv"); + glVertexAttrib4Nbv = cast(typeof(glVertexAttrib4Nbv))load("glVertexAttrib4Nbv"); + glVertexAttrib4Niv = cast(typeof(glVertexAttrib4Niv))load("glVertexAttrib4Niv"); + glVertexAttrib4Nsv = cast(typeof(glVertexAttrib4Nsv))load("glVertexAttrib4Nsv"); + glVertexAttrib4Nub = cast(typeof(glVertexAttrib4Nub))load("glVertexAttrib4Nub"); + glVertexAttrib4Nubv = cast(typeof(glVertexAttrib4Nubv))load("glVertexAttrib4Nubv"); + glVertexAttrib4Nuiv = cast(typeof(glVertexAttrib4Nuiv))load("glVertexAttrib4Nuiv"); + glVertexAttrib4Nusv = cast(typeof(glVertexAttrib4Nusv))load("glVertexAttrib4Nusv"); + glVertexAttrib4bv = cast(typeof(glVertexAttrib4bv))load("glVertexAttrib4bv"); + glVertexAttrib4d = cast(typeof(glVertexAttrib4d))load("glVertexAttrib4d"); + glVertexAttrib4dv = cast(typeof(glVertexAttrib4dv))load("glVertexAttrib4dv"); + glVertexAttrib4f = cast(typeof(glVertexAttrib4f))load("glVertexAttrib4f"); + glVertexAttrib4fv = cast(typeof(glVertexAttrib4fv))load("glVertexAttrib4fv"); + glVertexAttrib4iv = cast(typeof(glVertexAttrib4iv))load("glVertexAttrib4iv"); + glVertexAttrib4s = cast(typeof(glVertexAttrib4s))load("glVertexAttrib4s"); + glVertexAttrib4sv = cast(typeof(glVertexAttrib4sv))load("glVertexAttrib4sv"); + glVertexAttrib4ubv = cast(typeof(glVertexAttrib4ubv))load("glVertexAttrib4ubv"); + glVertexAttrib4uiv = cast(typeof(glVertexAttrib4uiv))load("glVertexAttrib4uiv"); + glVertexAttrib4usv = cast(typeof(glVertexAttrib4usv))load("glVertexAttrib4usv"); + glVertexAttribPointer = cast(typeof(glVertexAttribPointer))load("glVertexAttribPointer"); + return; +} + +void load_GL_VERSION_2_1(Loader load) { + if(!GL_VERSION_2_1) return; + glUniformMatrix2x3fv = cast(typeof(glUniformMatrix2x3fv))load("glUniformMatrix2x3fv"); + glUniformMatrix3x2fv = cast(typeof(glUniformMatrix3x2fv))load("glUniformMatrix3x2fv"); + glUniformMatrix2x4fv = cast(typeof(glUniformMatrix2x4fv))load("glUniformMatrix2x4fv"); + glUniformMatrix4x2fv = cast(typeof(glUniformMatrix4x2fv))load("glUniformMatrix4x2fv"); + glUniformMatrix3x4fv = cast(typeof(glUniformMatrix3x4fv))load("glUniformMatrix3x4fv"); + glUniformMatrix4x3fv = cast(typeof(glUniformMatrix4x3fv))load("glUniformMatrix4x3fv"); + return; +} + +void load_GL_VERSION_3_0(Loader load) { + if(!GL_VERSION_3_0) return; + glColorMaski = cast(typeof(glColorMaski))load("glColorMaski"); + glGetBooleani_v = cast(typeof(glGetBooleani_v))load("glGetBooleani_v"); + glGetIntegeri_v = cast(typeof(glGetIntegeri_v))load("glGetIntegeri_v"); + glEnablei = cast(typeof(glEnablei))load("glEnablei"); + glDisablei = cast(typeof(glDisablei))load("glDisablei"); + glIsEnabledi = cast(typeof(glIsEnabledi))load("glIsEnabledi"); + glBeginTransformFeedback = cast(typeof(glBeginTransformFeedback))load("glBeginTransformFeedback"); + glEndTransformFeedback = cast(typeof(glEndTransformFeedback))load("glEndTransformFeedback"); + glBindBufferRange = cast(typeof(glBindBufferRange))load("glBindBufferRange"); + glBindBufferBase = cast(typeof(glBindBufferBase))load("glBindBufferBase"); + glTransformFeedbackVaryings = cast(typeof(glTransformFeedbackVaryings))load("glTransformFeedbackVaryings"); + glGetTransformFeedbackVarying = cast(typeof(glGetTransformFeedbackVarying))load("glGetTransformFeedbackVarying"); + glClampColor = cast(typeof(glClampColor))load("glClampColor"); + glBeginConditionalRender = cast(typeof(glBeginConditionalRender))load("glBeginConditionalRender"); + glEndConditionalRender = cast(typeof(glEndConditionalRender))load("glEndConditionalRender"); + glVertexAttribIPointer = cast(typeof(glVertexAttribIPointer))load("glVertexAttribIPointer"); + glGetVertexAttribIiv = cast(typeof(glGetVertexAttribIiv))load("glGetVertexAttribIiv"); + glGetVertexAttribIuiv = cast(typeof(glGetVertexAttribIuiv))load("glGetVertexAttribIuiv"); + glVertexAttribI1i = cast(typeof(glVertexAttribI1i))load("glVertexAttribI1i"); + glVertexAttribI2i = cast(typeof(glVertexAttribI2i))load("glVertexAttribI2i"); + glVertexAttribI3i = cast(typeof(glVertexAttribI3i))load("glVertexAttribI3i"); + glVertexAttribI4i = cast(typeof(glVertexAttribI4i))load("glVertexAttribI4i"); + glVertexAttribI1ui = cast(typeof(glVertexAttribI1ui))load("glVertexAttribI1ui"); + glVertexAttribI2ui = cast(typeof(glVertexAttribI2ui))load("glVertexAttribI2ui"); + glVertexAttribI3ui = cast(typeof(glVertexAttribI3ui))load("glVertexAttribI3ui"); + glVertexAttribI4ui = cast(typeof(glVertexAttribI4ui))load("glVertexAttribI4ui"); + glVertexAttribI1iv = cast(typeof(glVertexAttribI1iv))load("glVertexAttribI1iv"); + glVertexAttribI2iv = cast(typeof(glVertexAttribI2iv))load("glVertexAttribI2iv"); + glVertexAttribI3iv = cast(typeof(glVertexAttribI3iv))load("glVertexAttribI3iv"); + glVertexAttribI4iv = cast(typeof(glVertexAttribI4iv))load("glVertexAttribI4iv"); + glVertexAttribI1uiv = cast(typeof(glVertexAttribI1uiv))load("glVertexAttribI1uiv"); + glVertexAttribI2uiv = cast(typeof(glVertexAttribI2uiv))load("glVertexAttribI2uiv"); + glVertexAttribI3uiv = cast(typeof(glVertexAttribI3uiv))load("glVertexAttribI3uiv"); + glVertexAttribI4uiv = cast(typeof(glVertexAttribI4uiv))load("glVertexAttribI4uiv"); + glVertexAttribI4bv = cast(typeof(glVertexAttribI4bv))load("glVertexAttribI4bv"); + glVertexAttribI4sv = cast(typeof(glVertexAttribI4sv))load("glVertexAttribI4sv"); + glVertexAttribI4ubv = cast(typeof(glVertexAttribI4ubv))load("glVertexAttribI4ubv"); + glVertexAttribI4usv = cast(typeof(glVertexAttribI4usv))load("glVertexAttribI4usv"); + glGetUniformuiv = cast(typeof(glGetUniformuiv))load("glGetUniformuiv"); + glBindFragDataLocation = cast(typeof(glBindFragDataLocation))load("glBindFragDataLocation"); + glGetFragDataLocation = cast(typeof(glGetFragDataLocation))load("glGetFragDataLocation"); + glUniform1ui = cast(typeof(glUniform1ui))load("glUniform1ui"); + glUniform2ui = cast(typeof(glUniform2ui))load("glUniform2ui"); + glUniform3ui = cast(typeof(glUniform3ui))load("glUniform3ui"); + glUniform4ui = cast(typeof(glUniform4ui))load("glUniform4ui"); + glUniform1uiv = cast(typeof(glUniform1uiv))load("glUniform1uiv"); + glUniform2uiv = cast(typeof(glUniform2uiv))load("glUniform2uiv"); + glUniform3uiv = cast(typeof(glUniform3uiv))load("glUniform3uiv"); + glUniform4uiv = cast(typeof(glUniform4uiv))load("glUniform4uiv"); + glTexParameterIiv = cast(typeof(glTexParameterIiv))load("glTexParameterIiv"); + glTexParameterIuiv = cast(typeof(glTexParameterIuiv))load("glTexParameterIuiv"); + glGetTexParameterIiv = cast(typeof(glGetTexParameterIiv))load("glGetTexParameterIiv"); + glGetTexParameterIuiv = cast(typeof(glGetTexParameterIuiv))load("glGetTexParameterIuiv"); + glClearBufferiv = cast(typeof(glClearBufferiv))load("glClearBufferiv"); + glClearBufferuiv = cast(typeof(glClearBufferuiv))load("glClearBufferuiv"); + glClearBufferfv = cast(typeof(glClearBufferfv))load("glClearBufferfv"); + glClearBufferfi = cast(typeof(glClearBufferfi))load("glClearBufferfi"); + glGetStringi = cast(typeof(glGetStringi))load("glGetStringi"); + glIsRenderbuffer = cast(typeof(glIsRenderbuffer))load("glIsRenderbuffer"); + glBindRenderbuffer = cast(typeof(glBindRenderbuffer))load("glBindRenderbuffer"); + glDeleteRenderbuffers = cast(typeof(glDeleteRenderbuffers))load("glDeleteRenderbuffers"); + glGenRenderbuffers = cast(typeof(glGenRenderbuffers))load("glGenRenderbuffers"); + glRenderbufferStorage = cast(typeof(glRenderbufferStorage))load("glRenderbufferStorage"); + glGetRenderbufferParameteriv = cast(typeof(glGetRenderbufferParameteriv))load("glGetRenderbufferParameteriv"); + glIsFramebuffer = cast(typeof(glIsFramebuffer))load("glIsFramebuffer"); + glBindFramebuffer = cast(typeof(glBindFramebuffer))load("glBindFramebuffer"); + glDeleteFramebuffers = cast(typeof(glDeleteFramebuffers))load("glDeleteFramebuffers"); + glGenFramebuffers = cast(typeof(glGenFramebuffers))load("glGenFramebuffers"); + glCheckFramebufferStatus = cast(typeof(glCheckFramebufferStatus))load("glCheckFramebufferStatus"); + glFramebufferTexture1D = cast(typeof(glFramebufferTexture1D))load("glFramebufferTexture1D"); + glFramebufferTexture2D = cast(typeof(glFramebufferTexture2D))load("glFramebufferTexture2D"); + glFramebufferTexture3D = cast(typeof(glFramebufferTexture3D))load("glFramebufferTexture3D"); + glFramebufferRenderbuffer = cast(typeof(glFramebufferRenderbuffer))load("glFramebufferRenderbuffer"); + glGetFramebufferAttachmentParameteriv = cast(typeof(glGetFramebufferAttachmentParameteriv))load("glGetFramebufferAttachmentParameteriv"); + glGenerateMipmap = cast(typeof(glGenerateMipmap))load("glGenerateMipmap"); + glBlitFramebuffer = cast(typeof(glBlitFramebuffer))load("glBlitFramebuffer"); + glRenderbufferStorageMultisample = cast(typeof(glRenderbufferStorageMultisample))load("glRenderbufferStorageMultisample"); + glFramebufferTextureLayer = cast(typeof(glFramebufferTextureLayer))load("glFramebufferTextureLayer"); + glMapBufferRange = cast(typeof(glMapBufferRange))load("glMapBufferRange"); + glFlushMappedBufferRange = cast(typeof(glFlushMappedBufferRange))load("glFlushMappedBufferRange"); + glBindVertexArray = cast(typeof(glBindVertexArray))load("glBindVertexArray"); + glDeleteVertexArrays = cast(typeof(glDeleteVertexArrays))load("glDeleteVertexArrays"); + glGenVertexArrays = cast(typeof(glGenVertexArrays))load("glGenVertexArrays"); + glIsVertexArray = cast(typeof(glIsVertexArray))load("glIsVertexArray"); + return; +} + +void load_GL_VERSION_3_1(Loader load) { + if(!GL_VERSION_3_1) return; + glDrawArraysInstanced = cast(typeof(glDrawArraysInstanced))load("glDrawArraysInstanced"); + glDrawElementsInstanced = cast(typeof(glDrawElementsInstanced))load("glDrawElementsInstanced"); + glTexBuffer = cast(typeof(glTexBuffer))load("glTexBuffer"); + glPrimitiveRestartIndex = cast(typeof(glPrimitiveRestartIndex))load("glPrimitiveRestartIndex"); + glCopyBufferSubData = cast(typeof(glCopyBufferSubData))load("glCopyBufferSubData"); + glGetUniformIndices = cast(typeof(glGetUniformIndices))load("glGetUniformIndices"); + glGetActiveUniformsiv = cast(typeof(glGetActiveUniformsiv))load("glGetActiveUniformsiv"); + glGetActiveUniformName = cast(typeof(glGetActiveUniformName))load("glGetActiveUniformName"); + glGetUniformBlockIndex = cast(typeof(glGetUniformBlockIndex))load("glGetUniformBlockIndex"); + glGetActiveUniformBlockiv = cast(typeof(glGetActiveUniformBlockiv))load("glGetActiveUniformBlockiv"); + glGetActiveUniformBlockName = cast(typeof(glGetActiveUniformBlockName))load("glGetActiveUniformBlockName"); + glUniformBlockBinding = cast(typeof(glUniformBlockBinding))load("glUniformBlockBinding"); + glBindBufferRange = cast(typeof(glBindBufferRange))load("glBindBufferRange"); + glBindBufferBase = cast(typeof(glBindBufferBase))load("glBindBufferBase"); + glGetIntegeri_v = cast(typeof(glGetIntegeri_v))load("glGetIntegeri_v"); + return; +} + +void load_GL_VERSION_3_2(Loader load) { + if(!GL_VERSION_3_2) return; + glDrawElementsBaseVertex = cast(typeof(glDrawElementsBaseVertex))load("glDrawElementsBaseVertex"); + glDrawRangeElementsBaseVertex = cast(typeof(glDrawRangeElementsBaseVertex))load("glDrawRangeElementsBaseVertex"); + glDrawElementsInstancedBaseVertex = cast(typeof(glDrawElementsInstancedBaseVertex))load("glDrawElementsInstancedBaseVertex"); + glMultiDrawElementsBaseVertex = cast(typeof(glMultiDrawElementsBaseVertex))load("glMultiDrawElementsBaseVertex"); + glProvokingVertex = cast(typeof(glProvokingVertex))load("glProvokingVertex"); + glFenceSync = cast(typeof(glFenceSync))load("glFenceSync"); + glIsSync = cast(typeof(glIsSync))load("glIsSync"); + glDeleteSync = cast(typeof(glDeleteSync))load("glDeleteSync"); + glClientWaitSync = cast(typeof(glClientWaitSync))load("glClientWaitSync"); + glWaitSync = cast(typeof(glWaitSync))load("glWaitSync"); + glGetInteger64v = cast(typeof(glGetInteger64v))load("glGetInteger64v"); + glGetSynciv = cast(typeof(glGetSynciv))load("glGetSynciv"); + glGetInteger64i_v = cast(typeof(glGetInteger64i_v))load("glGetInteger64i_v"); + glGetBufferParameteri64v = cast(typeof(glGetBufferParameteri64v))load("glGetBufferParameteri64v"); + glFramebufferTexture = cast(typeof(glFramebufferTexture))load("glFramebufferTexture"); + glTexImage2DMultisample = cast(typeof(glTexImage2DMultisample))load("glTexImage2DMultisample"); + glTexImage3DMultisample = cast(typeof(glTexImage3DMultisample))load("glTexImage3DMultisample"); + glGetMultisamplefv = cast(typeof(glGetMultisamplefv))load("glGetMultisamplefv"); + glSampleMaski = cast(typeof(glSampleMaski))load("glSampleMaski"); + return; +} + +void load_GL_VERSION_3_3(Loader load) { + if(!GL_VERSION_3_3) return; + glBindFragDataLocationIndexed = cast(typeof(glBindFragDataLocationIndexed))load("glBindFragDataLocationIndexed"); + glGetFragDataIndex = cast(typeof(glGetFragDataIndex))load("glGetFragDataIndex"); + glGenSamplers = cast(typeof(glGenSamplers))load("glGenSamplers"); + glDeleteSamplers = cast(typeof(glDeleteSamplers))load("glDeleteSamplers"); + glIsSampler = cast(typeof(glIsSampler))load("glIsSampler"); + glBindSampler = cast(typeof(glBindSampler))load("glBindSampler"); + glSamplerParameteri = cast(typeof(glSamplerParameteri))load("glSamplerParameteri"); + glSamplerParameteriv = cast(typeof(glSamplerParameteriv))load("glSamplerParameteriv"); + glSamplerParameterf = cast(typeof(glSamplerParameterf))load("glSamplerParameterf"); + glSamplerParameterfv = cast(typeof(glSamplerParameterfv))load("glSamplerParameterfv"); + glSamplerParameterIiv = cast(typeof(glSamplerParameterIiv))load("glSamplerParameterIiv"); + glSamplerParameterIuiv = cast(typeof(glSamplerParameterIuiv))load("glSamplerParameterIuiv"); + glGetSamplerParameteriv = cast(typeof(glGetSamplerParameteriv))load("glGetSamplerParameteriv"); + glGetSamplerParameterIiv = cast(typeof(glGetSamplerParameterIiv))load("glGetSamplerParameterIiv"); + glGetSamplerParameterfv = cast(typeof(glGetSamplerParameterfv))load("glGetSamplerParameterfv"); + glGetSamplerParameterIuiv = cast(typeof(glGetSamplerParameterIuiv))load("glGetSamplerParameterIuiv"); + glQueryCounter = cast(typeof(glQueryCounter))load("glQueryCounter"); + glGetQueryObjecti64v = cast(typeof(glGetQueryObjecti64v))load("glGetQueryObjecti64v"); + glGetQueryObjectui64v = cast(typeof(glGetQueryObjectui64v))load("glGetQueryObjectui64v"); + glVertexAttribDivisor = cast(typeof(glVertexAttribDivisor))load("glVertexAttribDivisor"); + glVertexAttribP1ui = cast(typeof(glVertexAttribP1ui))load("glVertexAttribP1ui"); + glVertexAttribP1uiv = cast(typeof(glVertexAttribP1uiv))load("glVertexAttribP1uiv"); + glVertexAttribP2ui = cast(typeof(glVertexAttribP2ui))load("glVertexAttribP2ui"); + glVertexAttribP2uiv = cast(typeof(glVertexAttribP2uiv))load("glVertexAttribP2uiv"); + glVertexAttribP3ui = cast(typeof(glVertexAttribP3ui))load("glVertexAttribP3ui"); + glVertexAttribP3uiv = cast(typeof(glVertexAttribP3uiv))load("glVertexAttribP3uiv"); + glVertexAttribP4ui = cast(typeof(glVertexAttribP4ui))load("glVertexAttribP4ui"); + glVertexAttribP4uiv = cast(typeof(glVertexAttribP4uiv))load("glVertexAttribP4uiv"); + glVertexP2ui = cast(typeof(glVertexP2ui))load("glVertexP2ui"); + glVertexP2uiv = cast(typeof(glVertexP2uiv))load("glVertexP2uiv"); + glVertexP3ui = cast(typeof(glVertexP3ui))load("glVertexP3ui"); + glVertexP3uiv = cast(typeof(glVertexP3uiv))load("glVertexP3uiv"); + glVertexP4ui = cast(typeof(glVertexP4ui))load("glVertexP4ui"); + glVertexP4uiv = cast(typeof(glVertexP4uiv))load("glVertexP4uiv"); + glTexCoordP1ui = cast(typeof(glTexCoordP1ui))load("glTexCoordP1ui"); + glTexCoordP1uiv = cast(typeof(glTexCoordP1uiv))load("glTexCoordP1uiv"); + glTexCoordP2ui = cast(typeof(glTexCoordP2ui))load("glTexCoordP2ui"); + glTexCoordP2uiv = cast(typeof(glTexCoordP2uiv))load("glTexCoordP2uiv"); + glTexCoordP3ui = cast(typeof(glTexCoordP3ui))load("glTexCoordP3ui"); + glTexCoordP3uiv = cast(typeof(glTexCoordP3uiv))load("glTexCoordP3uiv"); + glTexCoordP4ui = cast(typeof(glTexCoordP4ui))load("glTexCoordP4ui"); + glTexCoordP4uiv = cast(typeof(glTexCoordP4uiv))load("glTexCoordP4uiv"); + glMultiTexCoordP1ui = cast(typeof(glMultiTexCoordP1ui))load("glMultiTexCoordP1ui"); + glMultiTexCoordP1uiv = cast(typeof(glMultiTexCoordP1uiv))load("glMultiTexCoordP1uiv"); + glMultiTexCoordP2ui = cast(typeof(glMultiTexCoordP2ui))load("glMultiTexCoordP2ui"); + glMultiTexCoordP2uiv = cast(typeof(glMultiTexCoordP2uiv))load("glMultiTexCoordP2uiv"); + glMultiTexCoordP3ui = cast(typeof(glMultiTexCoordP3ui))load("glMultiTexCoordP3ui"); + glMultiTexCoordP3uiv = cast(typeof(glMultiTexCoordP3uiv))load("glMultiTexCoordP3uiv"); + glMultiTexCoordP4ui = cast(typeof(glMultiTexCoordP4ui))load("glMultiTexCoordP4ui"); + glMultiTexCoordP4uiv = cast(typeof(glMultiTexCoordP4uiv))load("glMultiTexCoordP4uiv"); + glNormalP3ui = cast(typeof(glNormalP3ui))load("glNormalP3ui"); + glNormalP3uiv = cast(typeof(glNormalP3uiv))load("glNormalP3uiv"); + glColorP3ui = cast(typeof(glColorP3ui))load("glColorP3ui"); + glColorP3uiv = cast(typeof(glColorP3uiv))load("glColorP3uiv"); + glColorP4ui = cast(typeof(glColorP4ui))load("glColorP4ui"); + glColorP4uiv = cast(typeof(glColorP4uiv))load("glColorP4uiv"); + glSecondaryColorP3ui = cast(typeof(glSecondaryColorP3ui))load("glSecondaryColorP3ui"); + glSecondaryColorP3uiv = cast(typeof(glSecondaryColorP3uiv))load("glSecondaryColorP3uiv"); + return; +} + + +} /* private */ + +bool gladLoadGLES2(Loader load) { + glGetString = cast(typeof(glGetString))load("glGetString"); + if(glGetString is null) { return false; } + if(glGetString(GL_VERSION) is null) { return false; } + + find_coreGLES2(); + load_GL_ES_VERSION_2_0(load); + load_GL_ES_VERSION_3_0(load); + + find_extensionsGLES2(); + return GLVersion.major != 0 || GLVersion.minor != 0; +} + +private { + +void find_coreGLES2() { + + // Thank you @elmindreda + // https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + // https://github.com/glfw/glfw/blob/master/src/context.c#L36 + int i; + const(char)* glversion; + const(char)*[3] prefixes = [ + "OpenGL ES-CM ".ptr, + "OpenGL ES-CL ".ptr, + "OpenGL ES ".ptr, + ]; + + glversion = cast(const(char)*)glGetString(GL_VERSION); + if (glversion is null) return; + + foreach(prefix; prefixes) { + size_t length = strlen(prefix); + if (strncmp(glversion, prefix, length) == 0) { + glversion += length; + break; + } + } + + int major = glversion[0] - '0'; + int minor = glversion[2] - '0'; + GLVersion.major = major; GLVersion.minor = minor; + GL_ES_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GL_ES_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + return; +} + +void find_extensionsGLES2() { + return; +} + +void load_GL_ES_VERSION_2_0(Loader load) { + if(!GL_ES_VERSION_2_0) return; + glActiveTexture = cast(typeof(glActiveTexture))load("glActiveTexture"); + glAttachShader = cast(typeof(glAttachShader))load("glAttachShader"); + glBindAttribLocation = cast(typeof(glBindAttribLocation))load("glBindAttribLocation"); + glBindBuffer = cast(typeof(glBindBuffer))load("glBindBuffer"); + glBindFramebuffer = cast(typeof(glBindFramebuffer))load("glBindFramebuffer"); + glBindRenderbuffer = cast(typeof(glBindRenderbuffer))load("glBindRenderbuffer"); + glBindTexture = cast(typeof(glBindTexture))load("glBindTexture"); + glBlendColor = cast(typeof(glBlendColor))load("glBlendColor"); + glBlendEquation = cast(typeof(glBlendEquation))load("glBlendEquation"); + glBlendEquationSeparate = cast(typeof(glBlendEquationSeparate))load("glBlendEquationSeparate"); + glBlendFunc = cast(typeof(glBlendFunc))load("glBlendFunc"); + glBlendFuncSeparate = cast(typeof(glBlendFuncSeparate))load("glBlendFuncSeparate"); + glBufferData = cast(typeof(glBufferData))load("glBufferData"); + glBufferSubData = cast(typeof(glBufferSubData))load("glBufferSubData"); + glCheckFramebufferStatus = cast(typeof(glCheckFramebufferStatus))load("glCheckFramebufferStatus"); + glClear = cast(typeof(glClear))load("glClear"); + glClearColor = cast(typeof(glClearColor))load("glClearColor"); + glClearDepthf = cast(typeof(glClearDepthf))load("glClearDepthf"); + glClearStencil = cast(typeof(glClearStencil))load("glClearStencil"); + glColorMask = cast(typeof(glColorMask))load("glColorMask"); + glCompileShader = cast(typeof(glCompileShader))load("glCompileShader"); + glCompressedTexImage2D = cast(typeof(glCompressedTexImage2D))load("glCompressedTexImage2D"); + glCompressedTexSubImage2D = cast(typeof(glCompressedTexSubImage2D))load("glCompressedTexSubImage2D"); + glCopyTexImage2D = cast(typeof(glCopyTexImage2D))load("glCopyTexImage2D"); + glCopyTexSubImage2D = cast(typeof(glCopyTexSubImage2D))load("glCopyTexSubImage2D"); + glCreateProgram = cast(typeof(glCreateProgram))load("glCreateProgram"); + glCreateShader = cast(typeof(glCreateShader))load("glCreateShader"); + glCullFace = cast(typeof(glCullFace))load("glCullFace"); + glDeleteBuffers = cast(typeof(glDeleteBuffers))load("glDeleteBuffers"); + glDeleteFramebuffers = cast(typeof(glDeleteFramebuffers))load("glDeleteFramebuffers"); + glDeleteProgram = cast(typeof(glDeleteProgram))load("glDeleteProgram"); + glDeleteRenderbuffers = cast(typeof(glDeleteRenderbuffers))load("glDeleteRenderbuffers"); + glDeleteShader = cast(typeof(glDeleteShader))load("glDeleteShader"); + glDeleteTextures = cast(typeof(glDeleteTextures))load("glDeleteTextures"); + glDepthFunc = cast(typeof(glDepthFunc))load("glDepthFunc"); + glDepthMask = cast(typeof(glDepthMask))load("glDepthMask"); + glDepthRangef = cast(typeof(glDepthRangef))load("glDepthRangef"); + glDetachShader = cast(typeof(glDetachShader))load("glDetachShader"); + glDisable = cast(typeof(glDisable))load("glDisable"); + glDisableVertexAttribArray = cast(typeof(glDisableVertexAttribArray))load("glDisableVertexAttribArray"); + glDrawArrays = cast(typeof(glDrawArrays))load("glDrawArrays"); + glDrawElements = cast(typeof(glDrawElements))load("glDrawElements"); + glEnable = cast(typeof(glEnable))load("glEnable"); + glEnableVertexAttribArray = cast(typeof(glEnableVertexAttribArray))load("glEnableVertexAttribArray"); + glFinish = cast(typeof(glFinish))load("glFinish"); + glFlush = cast(typeof(glFlush))load("glFlush"); + glFramebufferRenderbuffer = cast(typeof(glFramebufferRenderbuffer))load("glFramebufferRenderbuffer"); + glFramebufferTexture2D = cast(typeof(glFramebufferTexture2D))load("glFramebufferTexture2D"); + glFrontFace = cast(typeof(glFrontFace))load("glFrontFace"); + glGenBuffers = cast(typeof(glGenBuffers))load("glGenBuffers"); + glGenerateMipmap = cast(typeof(glGenerateMipmap))load("glGenerateMipmap"); + glGenFramebuffers = cast(typeof(glGenFramebuffers))load("glGenFramebuffers"); + glGenRenderbuffers = cast(typeof(glGenRenderbuffers))load("glGenRenderbuffers"); + glGenTextures = cast(typeof(glGenTextures))load("glGenTextures"); + glGetActiveAttrib = cast(typeof(glGetActiveAttrib))load("glGetActiveAttrib"); + glGetActiveUniform = cast(typeof(glGetActiveUniform))load("glGetActiveUniform"); + glGetAttachedShaders = cast(typeof(glGetAttachedShaders))load("glGetAttachedShaders"); + glGetAttribLocation = cast(typeof(glGetAttribLocation))load("glGetAttribLocation"); + glGetBooleanv = cast(typeof(glGetBooleanv))load("glGetBooleanv"); + glGetBufferParameteriv = cast(typeof(glGetBufferParameteriv))load("glGetBufferParameteriv"); + glGetError = cast(typeof(glGetError))load("glGetError"); + glGetFloatv = cast(typeof(glGetFloatv))load("glGetFloatv"); + glGetFramebufferAttachmentParameteriv = cast(typeof(glGetFramebufferAttachmentParameteriv))load("glGetFramebufferAttachmentParameteriv"); + glGetIntegerv = cast(typeof(glGetIntegerv))load("glGetIntegerv"); + glGetProgramiv = cast(typeof(glGetProgramiv))load("glGetProgramiv"); + glGetProgramInfoLog = cast(typeof(glGetProgramInfoLog))load("glGetProgramInfoLog"); + glGetRenderbufferParameteriv = cast(typeof(glGetRenderbufferParameteriv))load("glGetRenderbufferParameteriv"); + glGetShaderiv = cast(typeof(glGetShaderiv))load("glGetShaderiv"); + glGetShaderInfoLog = cast(typeof(glGetShaderInfoLog))load("glGetShaderInfoLog"); + glGetShaderPrecisionFormat = cast(typeof(glGetShaderPrecisionFormat))load("glGetShaderPrecisionFormat"); + glGetShaderSource = cast(typeof(glGetShaderSource))load("glGetShaderSource"); + glGetString = cast(typeof(glGetString))load("glGetString"); + glGetTexParameterfv = cast(typeof(glGetTexParameterfv))load("glGetTexParameterfv"); + glGetTexParameteriv = cast(typeof(glGetTexParameteriv))load("glGetTexParameteriv"); + glGetUniformfv = cast(typeof(glGetUniformfv))load("glGetUniformfv"); + glGetUniformiv = cast(typeof(glGetUniformiv))load("glGetUniformiv"); + glGetUniformLocation = cast(typeof(glGetUniformLocation))load("glGetUniformLocation"); + glGetVertexAttribfv = cast(typeof(glGetVertexAttribfv))load("glGetVertexAttribfv"); + glGetVertexAttribiv = cast(typeof(glGetVertexAttribiv))load("glGetVertexAttribiv"); + glGetVertexAttribPointerv = cast(typeof(glGetVertexAttribPointerv))load("glGetVertexAttribPointerv"); + glHint = cast(typeof(glHint))load("glHint"); + glIsBuffer = cast(typeof(glIsBuffer))load("glIsBuffer"); + glIsEnabled = cast(typeof(glIsEnabled))load("glIsEnabled"); + glIsFramebuffer = cast(typeof(glIsFramebuffer))load("glIsFramebuffer"); + glIsProgram = cast(typeof(glIsProgram))load("glIsProgram"); + glIsRenderbuffer = cast(typeof(glIsRenderbuffer))load("glIsRenderbuffer"); + glIsShader = cast(typeof(glIsShader))load("glIsShader"); + glIsTexture = cast(typeof(glIsTexture))load("glIsTexture"); + glLineWidth = cast(typeof(glLineWidth))load("glLineWidth"); + glLinkProgram = cast(typeof(glLinkProgram))load("glLinkProgram"); + glPixelStorei = cast(typeof(glPixelStorei))load("glPixelStorei"); + glPolygonOffset = cast(typeof(glPolygonOffset))load("glPolygonOffset"); + glReadPixels = cast(typeof(glReadPixels))load("glReadPixels"); + glReleaseShaderCompiler = cast(typeof(glReleaseShaderCompiler))load("glReleaseShaderCompiler"); + glRenderbufferStorage = cast(typeof(glRenderbufferStorage))load("glRenderbufferStorage"); + glSampleCoverage = cast(typeof(glSampleCoverage))load("glSampleCoverage"); + glScissor = cast(typeof(glScissor))load("glScissor"); + glShaderBinary = cast(typeof(glShaderBinary))load("glShaderBinary"); + glShaderSource = cast(typeof(glShaderSource))load("glShaderSource"); + glStencilFunc = cast(typeof(glStencilFunc))load("glStencilFunc"); + glStencilFuncSeparate = cast(typeof(glStencilFuncSeparate))load("glStencilFuncSeparate"); + glStencilMask = cast(typeof(glStencilMask))load("glStencilMask"); + glStencilMaskSeparate = cast(typeof(glStencilMaskSeparate))load("glStencilMaskSeparate"); + glStencilOp = cast(typeof(glStencilOp))load("glStencilOp"); + glStencilOpSeparate = cast(typeof(glStencilOpSeparate))load("glStencilOpSeparate"); + glTexImage2D = cast(typeof(glTexImage2D))load("glTexImage2D"); + glTexParameterf = cast(typeof(glTexParameterf))load("glTexParameterf"); + glTexParameterfv = cast(typeof(glTexParameterfv))load("glTexParameterfv"); + glTexParameteri = cast(typeof(glTexParameteri))load("glTexParameteri"); + glTexParameteriv = cast(typeof(glTexParameteriv))load("glTexParameteriv"); + glTexSubImage2D = cast(typeof(glTexSubImage2D))load("glTexSubImage2D"); + glUniform1f = cast(typeof(glUniform1f))load("glUniform1f"); + glUniform1fv = cast(typeof(glUniform1fv))load("glUniform1fv"); + glUniform1i = cast(typeof(glUniform1i))load("glUniform1i"); + glUniform1iv = cast(typeof(glUniform1iv))load("glUniform1iv"); + glUniform2f = cast(typeof(glUniform2f))load("glUniform2f"); + glUniform2fv = cast(typeof(glUniform2fv))load("glUniform2fv"); + glUniform2i = cast(typeof(glUniform2i))load("glUniform2i"); + glUniform2iv = cast(typeof(glUniform2iv))load("glUniform2iv"); + glUniform3f = cast(typeof(glUniform3f))load("glUniform3f"); + glUniform3fv = cast(typeof(glUniform3fv))load("glUniform3fv"); + glUniform3i = cast(typeof(glUniform3i))load("glUniform3i"); + glUniform3iv = cast(typeof(glUniform3iv))load("glUniform3iv"); + glUniform4f = cast(typeof(glUniform4f))load("glUniform4f"); + glUniform4fv = cast(typeof(glUniform4fv))load("glUniform4fv"); + glUniform4i = cast(typeof(glUniform4i))load("glUniform4i"); + glUniform4iv = cast(typeof(glUniform4iv))load("glUniform4iv"); + glUniformMatrix2fv = cast(typeof(glUniformMatrix2fv))load("glUniformMatrix2fv"); + glUniformMatrix3fv = cast(typeof(glUniformMatrix3fv))load("glUniformMatrix3fv"); + glUniformMatrix4fv = cast(typeof(glUniformMatrix4fv))load("glUniformMatrix4fv"); + glUseProgram = cast(typeof(glUseProgram))load("glUseProgram"); + glValidateProgram = cast(typeof(glValidateProgram))load("glValidateProgram"); + glVertexAttrib1f = cast(typeof(glVertexAttrib1f))load("glVertexAttrib1f"); + glVertexAttrib1fv = cast(typeof(glVertexAttrib1fv))load("glVertexAttrib1fv"); + glVertexAttrib2f = cast(typeof(glVertexAttrib2f))load("glVertexAttrib2f"); + glVertexAttrib2fv = cast(typeof(glVertexAttrib2fv))load("glVertexAttrib2fv"); + glVertexAttrib3f = cast(typeof(glVertexAttrib3f))load("glVertexAttrib3f"); + glVertexAttrib3fv = cast(typeof(glVertexAttrib3fv))load("glVertexAttrib3fv"); + glVertexAttrib4f = cast(typeof(glVertexAttrib4f))load("glVertexAttrib4f"); + glVertexAttrib4fv = cast(typeof(glVertexAttrib4fv))load("glVertexAttrib4fv"); + glVertexAttribPointer = cast(typeof(glVertexAttribPointer))load("glVertexAttribPointer"); + glViewport = cast(typeof(glViewport))load("glViewport"); + return; +} + +void load_GL_ES_VERSION_3_0(Loader load) { + if(!GL_ES_VERSION_3_0) return; + glReadBuffer = cast(typeof(glReadBuffer))load("glReadBuffer"); + glDrawRangeElements = cast(typeof(glDrawRangeElements))load("glDrawRangeElements"); + glTexImage3D = cast(typeof(glTexImage3D))load("glTexImage3D"); + glTexSubImage3D = cast(typeof(glTexSubImage3D))load("glTexSubImage3D"); + glCopyTexSubImage3D = cast(typeof(glCopyTexSubImage3D))load("glCopyTexSubImage3D"); + glCompressedTexImage3D = cast(typeof(glCompressedTexImage3D))load("glCompressedTexImage3D"); + glCompressedTexSubImage3D = cast(typeof(glCompressedTexSubImage3D))load("glCompressedTexSubImage3D"); + glGenQueries = cast(typeof(glGenQueries))load("glGenQueries"); + glDeleteQueries = cast(typeof(glDeleteQueries))load("glDeleteQueries"); + glIsQuery = cast(typeof(glIsQuery))load("glIsQuery"); + glBeginQuery = cast(typeof(glBeginQuery))load("glBeginQuery"); + glEndQuery = cast(typeof(glEndQuery))load("glEndQuery"); + glGetQueryiv = cast(typeof(glGetQueryiv))load("glGetQueryiv"); + glGetQueryObjectuiv = cast(typeof(glGetQueryObjectuiv))load("glGetQueryObjectuiv"); + glUnmapBuffer = cast(typeof(glUnmapBuffer))load("glUnmapBuffer"); + glGetBufferPointerv = cast(typeof(glGetBufferPointerv))load("glGetBufferPointerv"); + glDrawBuffers = cast(typeof(glDrawBuffers))load("glDrawBuffers"); + glUniformMatrix2x3fv = cast(typeof(glUniformMatrix2x3fv))load("glUniformMatrix2x3fv"); + glUniformMatrix3x2fv = cast(typeof(glUniformMatrix3x2fv))load("glUniformMatrix3x2fv"); + glUniformMatrix2x4fv = cast(typeof(glUniformMatrix2x4fv))load("glUniformMatrix2x4fv"); + glUniformMatrix4x2fv = cast(typeof(glUniformMatrix4x2fv))load("glUniformMatrix4x2fv"); + glUniformMatrix3x4fv = cast(typeof(glUniformMatrix3x4fv))load("glUniformMatrix3x4fv"); + glUniformMatrix4x3fv = cast(typeof(glUniformMatrix4x3fv))load("glUniformMatrix4x3fv"); + glBlitFramebuffer = cast(typeof(glBlitFramebuffer))load("glBlitFramebuffer"); + glRenderbufferStorageMultisample = cast(typeof(glRenderbufferStorageMultisample))load("glRenderbufferStorageMultisample"); + glFramebufferTextureLayer = cast(typeof(glFramebufferTextureLayer))load("glFramebufferTextureLayer"); + glMapBufferRange = cast(typeof(glMapBufferRange))load("glMapBufferRange"); + glFlushMappedBufferRange = cast(typeof(glFlushMappedBufferRange))load("glFlushMappedBufferRange"); + glBindVertexArray = cast(typeof(glBindVertexArray))load("glBindVertexArray"); + glDeleteVertexArrays = cast(typeof(glDeleteVertexArrays))load("glDeleteVertexArrays"); + glGenVertexArrays = cast(typeof(glGenVertexArrays))load("glGenVertexArrays"); + glIsVertexArray = cast(typeof(glIsVertexArray))load("glIsVertexArray"); + glGetIntegeri_v = cast(typeof(glGetIntegeri_v))load("glGetIntegeri_v"); + glBeginTransformFeedback = cast(typeof(glBeginTransformFeedback))load("glBeginTransformFeedback"); + glEndTransformFeedback = cast(typeof(glEndTransformFeedback))load("glEndTransformFeedback"); + glBindBufferRange = cast(typeof(glBindBufferRange))load("glBindBufferRange"); + glBindBufferBase = cast(typeof(glBindBufferBase))load("glBindBufferBase"); + glTransformFeedbackVaryings = cast(typeof(glTransformFeedbackVaryings))load("glTransformFeedbackVaryings"); + glGetTransformFeedbackVarying = cast(typeof(glGetTransformFeedbackVarying))load("glGetTransformFeedbackVarying"); + glVertexAttribIPointer = cast(typeof(glVertexAttribIPointer))load("glVertexAttribIPointer"); + glGetVertexAttribIiv = cast(typeof(glGetVertexAttribIiv))load("glGetVertexAttribIiv"); + glGetVertexAttribIuiv = cast(typeof(glGetVertexAttribIuiv))load("glGetVertexAttribIuiv"); + glVertexAttribI4i = cast(typeof(glVertexAttribI4i))load("glVertexAttribI4i"); + glVertexAttribI4ui = cast(typeof(glVertexAttribI4ui))load("glVertexAttribI4ui"); + glVertexAttribI4iv = cast(typeof(glVertexAttribI4iv))load("glVertexAttribI4iv"); + glVertexAttribI4uiv = cast(typeof(glVertexAttribI4uiv))load("glVertexAttribI4uiv"); + glGetUniformuiv = cast(typeof(glGetUniformuiv))load("glGetUniformuiv"); + glGetFragDataLocation = cast(typeof(glGetFragDataLocation))load("glGetFragDataLocation"); + glUniform1ui = cast(typeof(glUniform1ui))load("glUniform1ui"); + glUniform2ui = cast(typeof(glUniform2ui))load("glUniform2ui"); + glUniform3ui = cast(typeof(glUniform3ui))load("glUniform3ui"); + glUniform4ui = cast(typeof(glUniform4ui))load("glUniform4ui"); + glUniform1uiv = cast(typeof(glUniform1uiv))load("glUniform1uiv"); + glUniform2uiv = cast(typeof(glUniform2uiv))load("glUniform2uiv"); + glUniform3uiv = cast(typeof(glUniform3uiv))load("glUniform3uiv"); + glUniform4uiv = cast(typeof(glUniform4uiv))load("glUniform4uiv"); + glClearBufferiv = cast(typeof(glClearBufferiv))load("glClearBufferiv"); + glClearBufferuiv = cast(typeof(glClearBufferuiv))load("glClearBufferuiv"); + glClearBufferfv = cast(typeof(glClearBufferfv))load("glClearBufferfv"); + glClearBufferfi = cast(typeof(glClearBufferfi))load("glClearBufferfi"); + glGetStringi = cast(typeof(glGetStringi))load("glGetStringi"); + glCopyBufferSubData = cast(typeof(glCopyBufferSubData))load("glCopyBufferSubData"); + glGetUniformIndices = cast(typeof(glGetUniformIndices))load("glGetUniformIndices"); + glGetActiveUniformsiv = cast(typeof(glGetActiveUniformsiv))load("glGetActiveUniformsiv"); + glGetUniformBlockIndex = cast(typeof(glGetUniformBlockIndex))load("glGetUniformBlockIndex"); + glGetActiveUniformBlockiv = cast(typeof(glGetActiveUniformBlockiv))load("glGetActiveUniformBlockiv"); + glGetActiveUniformBlockName = cast(typeof(glGetActiveUniformBlockName))load("glGetActiveUniformBlockName"); + glUniformBlockBinding = cast(typeof(glUniformBlockBinding))load("glUniformBlockBinding"); + glDrawArraysInstanced = cast(typeof(glDrawArraysInstanced))load("glDrawArraysInstanced"); + glDrawElementsInstanced = cast(typeof(glDrawElementsInstanced))load("glDrawElementsInstanced"); + glFenceSync = cast(typeof(glFenceSync))load("glFenceSync"); + glIsSync = cast(typeof(glIsSync))load("glIsSync"); + glDeleteSync = cast(typeof(glDeleteSync))load("glDeleteSync"); + glClientWaitSync = cast(typeof(glClientWaitSync))load("glClientWaitSync"); + glWaitSync = cast(typeof(glWaitSync))load("glWaitSync"); + glGetInteger64v = cast(typeof(glGetInteger64v))load("glGetInteger64v"); + glGetSynciv = cast(typeof(glGetSynciv))load("glGetSynciv"); + glGetInteger64i_v = cast(typeof(glGetInteger64i_v))load("glGetInteger64i_v"); + glGetBufferParameteri64v = cast(typeof(glGetBufferParameteri64v))load("glGetBufferParameteri64v"); + glGenSamplers = cast(typeof(glGenSamplers))load("glGenSamplers"); + glDeleteSamplers = cast(typeof(glDeleteSamplers))load("glDeleteSamplers"); + glIsSampler = cast(typeof(glIsSampler))load("glIsSampler"); + glBindSampler = cast(typeof(glBindSampler))load("glBindSampler"); + glSamplerParameteri = cast(typeof(glSamplerParameteri))load("glSamplerParameteri"); + glSamplerParameteriv = cast(typeof(glSamplerParameteriv))load("glSamplerParameteriv"); + glSamplerParameterf = cast(typeof(glSamplerParameterf))load("glSamplerParameterf"); + glSamplerParameterfv = cast(typeof(glSamplerParameterfv))load("glSamplerParameterfv"); + glGetSamplerParameteriv = cast(typeof(glGetSamplerParameteriv))load("glGetSamplerParameteriv"); + glGetSamplerParameterfv = cast(typeof(glGetSamplerParameterfv))load("glGetSamplerParameterfv"); + glVertexAttribDivisor = cast(typeof(glVertexAttribDivisor))load("glVertexAttribDivisor"); + glBindTransformFeedback = cast(typeof(glBindTransformFeedback))load("glBindTransformFeedback"); + glDeleteTransformFeedbacks = cast(typeof(glDeleteTransformFeedbacks))load("glDeleteTransformFeedbacks"); + glGenTransformFeedbacks = cast(typeof(glGenTransformFeedbacks))load("glGenTransformFeedbacks"); + glIsTransformFeedback = cast(typeof(glIsTransformFeedback))load("glIsTransformFeedback"); + glPauseTransformFeedback = cast(typeof(glPauseTransformFeedback))load("glPauseTransformFeedback"); + glResumeTransformFeedback = cast(typeof(glResumeTransformFeedback))load("glResumeTransformFeedback"); + glGetProgramBinary = cast(typeof(glGetProgramBinary))load("glGetProgramBinary"); + glProgramBinary = cast(typeof(glProgramBinary))load("glProgramBinary"); + glProgramParameteri = cast(typeof(glProgramParameteri))load("glProgramParameteri"); + glInvalidateFramebuffer = cast(typeof(glInvalidateFramebuffer))load("glInvalidateFramebuffer"); + glInvalidateSubFramebuffer = cast(typeof(glInvalidateSubFramebuffer))load("glInvalidateSubFramebuffer"); + glTexStorage2D = cast(typeof(glTexStorage2D))load("glTexStorage2D"); + glTexStorage3D = cast(typeof(glTexStorage3D))load("glTexStorage3D"); + glGetInternalformativ = cast(typeof(glGetInternalformativ))load("glGetInternalformativ"); + return; +} + + +} /* private */ + diff --git a/demos/external/sources/glad/gl/types.d b/demos/external/sources/glad/gl/types.d new file mode 100644 index 0000000..043a2a1 --- /dev/null +++ b/demos/external/sources/glad/gl/types.d @@ -0,0 +1,46 @@ +module glad.gl.types; + + +alias GLvoid = void; +alias GLintptr = ptrdiff_t; +alias GLsizei = int; +alias GLchar = char; +alias GLcharARB = byte; +alias GLushort = ushort; +alias GLint64EXT = long; +alias GLshort = short; +alias GLuint64 = ulong; +alias GLhalfARB = ushort; +alias GLubyte = ubyte; +alias GLdouble = double; +alias GLhandleARB = uint; +alias GLint64 = long; +alias GLenum = uint; +alias GLeglImageOES = void*; +alias GLintptrARB = ptrdiff_t; +alias GLsizeiptr = ptrdiff_t; +alias GLint = int; +alias GLboolean = ubyte; +alias GLbitfield = uint; +alias GLsizeiptrARB = ptrdiff_t; +alias GLfloat = float; +alias GLuint64EXT = ulong; +alias GLclampf = float; +alias GLbyte = byte; +alias GLclampd = double; +alias GLuint = uint; +alias GLvdpauSurfaceNV = ptrdiff_t; +alias GLfixed = int; +alias GLhalf = ushort; +alias GLclampx = int; +alias GLhalfNV = ushort; +struct ___GLsync; alias __GLsync = ___GLsync*; +alias GLsync = __GLsync*; +struct __cl_context; alias _cl_context = __cl_context*; +struct __cl_event; alias _cl_event = __cl_event*; +extern(System) { +alias GLDEBUGPROC = void function(GLenum, GLenum, GLuint, GLenum, GLsizei, in GLchar*, GLvoid*); +alias GLDEBUGPROCARB = GLDEBUGPROC; +alias GLDEBUGPROCKHR = GLDEBUGPROC; +alias GLDEBUGPROCAMD = void function(GLuint, GLenum, GLenum, GLsizei, in GLchar*, GLvoid*); +} diff --git a/demos/external/sources/mmutils/thread_pool.d b/demos/external/sources/mmutils/thread_pool.d new file mode 100644 index 0000000..a986048 --- /dev/null +++ b/demos/external/sources/mmutils/thread_pool.d @@ -0,0 +1,1694 @@ +module mmutils.thread_pool; + +import core.atomic; +//import core.stdc.stdio; +//import core.stdc.stdlib : free, malloc, realloc; +//import core.stdc.string : memcpy; + + + +//import std.stdio; +import std.algorithm : map; + +version = MM_NO_LOGS; // Disable log creation +//version = MM_USE_POSIX_THREADS; // Use posix threads insted of standard library, required for betterC + +version (WebAssembly) +{ + extern(C) struct FILE + { + + } +} +else +{ + import core.stdc.stdio; +} + +////////////////////////////////////////////// +/////////////// BetterC Support ////////////// +////////////////////////////////////////////// + +version (D_BetterC) +{ + import ecs.std; + extern (C) __gshared int _d_eh_personality(int, int, size_t, void*, void*) + { + return 0; + } + + extern (C) __gshared void _d_eh_resume_unwind(void*) + { + return; + } + + extern (C) void* _d_allocmemory(size_t sz) + { + return malloc(sz); + } +} +else +{ + import core.stdc.stdlib; + import core.stdc.string; +} + +////////////////////////////////////////////// +//////////////////// Alloc /////////////////// +////////////////////////////////////////////// +T* makeVar(T)(T init) +{ + T* el = cast(T*) malloc(T.sizeof); + memcpy(el, &init, T.sizeof); + return el; +} + +T* makeVar(T)() +{ + T init; + T* el = cast(T*) malloc(T.sizeof); + memcpy(el, &init, T.sizeof); + return el; +} + +T[] makeVarArray(T)(int num, T init = T.init) +{ + T* ptr = cast(T*) malloc(num * (T.sizeof + T.sizeof % T.alignof)); + T[] arr = ptr[0 .. num]; + foreach (ref el; arr) + { + memcpy(&el, &init, T.sizeof); + } + return arr; +} + +void disposeVar(T)(T* var) +{ + free(var); +} + +void disposeArray(T)(T[] var) +{ + free(var.ptr); +} +////////////////////////////////////////////// +//////////////////// Timer /////////////////// +////////////////////////////////////////////// + +version (WebAssembly) +{ + alias int time_t; + alias int clockid_t; + enum CLOCK_REALTIME = 0; + + struct timespec + { + time_t tv_sec; + int tv_nsec; + } + + extern(C) int clock_gettime(clockid_t, timespec*) @nogc nothrow @system; +} + +/// High precison timer +long useconds() +{ + version (WebAssembly) + { + //import core.sys.posix.sys.time : gettimeofday, timeval; + + /*timeval t; + gettimeofday(&t, null); + + return t.tv_sec * 1_000_000 + t.tv_usec;*/ + + time_t time; + timespec spec; + + clock_gettime(CLOCK_REALTIME, &spec); + + //time = spec.tv_sec; + return spec.tv_sec * 1000_000 + spec.tv_nsec / 1000; + } + else version (Posix) + { + import core.sys.posix.sys.time : gettimeofday, timeval; + + timeval t; + gettimeofday(&t, null); + return t.tv_sec * 1_000_000 + t.tv_usec; + } + else version (Windows) + { + /*import core.sys.windows.windows : QueryPerformanceFrequency; + + __gshared double mul = -1; + if (mul < 0) + { + long frequency; + int ok = QueryPerformanceFrequency(&frequency); + assert(ok); + mul = 1_000_000.0 / frequency; + } + long ticks; + int ok = QueryPerformanceCounter(&ticks); + assert(ok); + return cast(long)(ticks * mul);*/ + return 0; + } + else + { + static assert("OS not supported."); + } +} + +////////////////////////////////////////////// +//////////////////// Pause /////////////////// +////////////////////////////////////////////// + +void instructionPause() +{ + version (X86_64) + { + version (LDC) + { + import ldc.gccbuiltins_x86 : __builtin_ia32_pause; + + __builtin_ia32_pause(); + } + else version (DigitalMars) + { + asm + { + rep; + nop; + } + + } + else + { + static assert(0); + } + } +} + +////////////////////////////////////////////// +///////////// Semaphore + Thread ///////////// +////////////////////////////////////////////// + +version (MM_USE_POSIX_THREADS) +{ + version (Posix) + { + import core.sys.posix.pthread; + import core.sys.posix.semaphore; + } + else version (WebAssembly) + { + extern(C): + //alias uint time_t; + struct pthread_attr_t + { + + } + + struct pthread_t + { + void* p; + uint x; + } + + /*struct timespec + { + time_t tv_sec; + int tv_nsec; + }*/ + + // pthread + int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*); + int pthread_join(pthread_t, void**); + void pthread_exit(void *retval); + + // semaphore.h + alias sem_t = void*; + int sem_init(sem_t*, int, uint); + int sem_wait(sem_t*); + int sem_trywait(sem_t*); + int sem_post(sem_t*); + int sem_destroy(sem_t*); + int sem_timedwait(sem_t* sem, const timespec* abstime); + //import core.sys.posix.pthread; + //import core.sys.posix.semaphore; + } + else version (Windows) + { + extern (C): + alias uint time_t; + struct pthread_attr_t + { + + } + + struct pthread_t + { + void* p; + uint x; + } + + struct timespec + { + time_t tv_sec; + int tv_nsec; + } + + // pthread + int pthread_create(pthread_t*, in pthread_attr_t*, void* function(void*), void*); + int pthread_join(pthread_t, void**); + void pthread_exit(void *retval); + + // semaphore.h + alias sem_t = void*; + int sem_init(sem_t*, int, uint); + int sem_wait(sem_t*); + int sem_trywait(sem_t*); + int sem_post(sem_t*); + int sem_destroy(sem_t*); + int sem_timedwait(sem_t* sem, const timespec* abstime); + } + else + { + static assert(false); + } + + struct Semaphore + { + sem_t mutex; + + void initialize() + { + sem_init(&mutex, 0, 0); + } + + void wait() + { + int ret = sem_wait(&mutex); + assert(ret == 0); + } + + bool tryWait() + { + //return true; + int ret = sem_trywait(&mutex); + return (ret == 0); + } + + bool timedWait(int usecs) + { + timespec tv; + // if there is no such a function look at it: https://stackoverflow.com/questions/5404277/porting-clock-gettime-to-windows + clock_gettime(CLOCK_REALTIME, &tv); + tv.tv_sec += usecs / 1_000_000; + tv.tv_nsec += (usecs % 1_000_000) * 1_000; + + int ret = sem_timedwait(&mutex, &tv); + return (ret == 0); + } + + void post() + { + int ret = sem_post(&mutex); + assert(ret == 0); + } + + void destroy() + { + sem_destroy(&mutex); + } + } + + private extern (C) void* threadRunFunc(void* threadVoid) + { + Thread* th = cast(Thread*) threadVoid; + + th.threadStart(); + + pthread_exit(null); + return null; + } + + struct Thread + { + alias DG = void delegate(); + + DG threadStart; + pthread_t handle; + + void start(DG dg) + { + threadStart = dg; + int ok = pthread_create(&handle, null, &threadRunFunc, cast(void*)&this); + assert(ok == 0); + } + + void join() + { + pthread_join(handle, null); + handle = handle.init; + threadStart = null; + } + } +} +else version(D_BetterC) +{ + version(Posix) + { + struct Semaphore + { + sem_t mutex; + + void initialize() + { + sem_init(&mutex, 0, 0); + } + + void wait() + { + int ret = sem_wait(&mutex); + assert(ret == 0); + } + + bool tryWait() + { + //return true; + int ret = sem_trywait(&mutex); + return (ret == 0); + } + + bool timedWait(int usecs) + { + timespec tv; + // if there is no such a function look at it: https://stackoverflow.com/questions/5404277/porting-clock-gettime-to-windows + clock_gettime(CLOCK_REALTIME, &tv); + tv.tv_sec += usecs / 1_000_000; + tv.tv_nsec += (usecs % 1_000_000) * 1_000; + + int ret = sem_timedwait(&mutex, &tv); + return (ret == 0); + } + + void post() + { + int ret = sem_post(&mutex); + assert(ret == 0); + } + + void destroy() + { + sem_destroy(&mutex); + } + } + + private extern (C) void* threadRunFunc(void* threadVoid) + { + Thread* th = cast(Thread*) threadVoid; + + th.threadStart(); + + pthread_exit(null); + return null; + } + + struct Thread + { + alias DG = void delegate(); + + DG threadStart; + pthread_t handle; + + void start(DG dg) + { + threadStart = dg; + int ok = pthread_create(&handle, null, &threadRunFunc, cast(void*)&this); + assert(ok == 0); + } + + void join() + { + pthread_join(handle, null); + handle = handle.init; + threadStart = null; + } + } + } + else version(Windows) + { + import core.stdc.stdint : uintptr_t; + import core.sys.windows.windows; + extern (Windows) alias btex_fptr = uint function(void*); + extern (C) uintptr_t _beginthreadex(void*, uint, btex_fptr, void*, uint, uint*) nothrow @nogc; + + struct Semaphore + { + HANDLE handle; + + void initialize() + { + handle = CreateSemaphoreA( null, 0, int.max, null ); + assert ( handle != handle.init ); + //throw new SyncError( "Unable to create semaphore" ); + } + + void wait() + { + DWORD rc = WaitForSingleObject( handle, INFINITE ); + //int ret = sem_wait(&mutex); + assert(rc == WAIT_OBJECT_0); + } + + bool tryWait() + { + switch ( WaitForSingleObject( handle, 0 ) ) + { + case WAIT_OBJECT_0: + return true; + case WAIT_TIMEOUT: + return false; + default: + assert(0);//throw new SyncError( "Unable to wait for semaphore" ); + } + } + + bool timedWait(int usecs) + { + /*timespec tv; + // if there is no such a function look at it: https://stackoverflow.com/questions/5404277/porting-clock-gettime-to-windows + clock_gettime(CLOCK_REALTIME, &tv); + tv.tv_sec += usecs / 1_000_000; + tv.tv_nsec += (usecs % 1_000_000) * 1_000; + + int ret = sem_timedwait(&mutex, &tv); + return (ret == 0);*/ + + switch ( WaitForSingleObject( handle, cast(uint) usecs / 1000 ) ) + { + case WAIT_OBJECT_0: + return true; + case WAIT_TIMEOUT: + return false; + default: + assert(0);//throw new SyncError( "Unable to wait for semaphore" ); + } + } + + void post() + { + assert(ReleaseSemaphore( handle, 1, null )); + //if ( !ReleaseSemaphore( m_hndl, 1, null ) ) + //throw new SyncError( "Unable to notify semaphore" ); + } + + void destroy() + { + BOOL rc = CloseHandle( handle ); + assert( rc, "Unable to destroy semaphore" ); + } + } + + private extern (Windows) uint threadRunFunc(void* threadVoid) + { + Thread* th = cast(Thread*) threadVoid; + + th.threadStart(); + + //(null); + ExitThread(0); + return 0; + } + + struct Thread + { + alias DG = void delegate(); + + DG threadStart; + HANDLE handle; + + void start(DG dg) + { + threadStart = dg; + handle = cast(HANDLE) _beginthreadex( null, 0, &threadRunFunc, cast(void*)&this, 0, null ); + //int ok = pthread_create(&handle, null, &threadRunFunc, cast(void*)&this); + assert(handle == null); + } + + void join() + { + if ( WaitForSingleObject( handle, INFINITE ) == WAIT_OBJECT_0 )assert(0); + CloseHandle( handle ); + //pthread_join(handle, null); + handle = handle.init; + threadStart = null; + } + } + } + +} +else +{ + import core.thread : D_Thread = Thread; + import core.sync.semaphore : D_Semaphore = Semaphore; + import core.time : dur; + import std.experimental.allocator; + import std.experimental.allocator.mallocator; + + struct Semaphore + { + D_Semaphore sem; + + void initialize() + { + sem = Mallocator.instance.make!D_Semaphore(); + } + + void wait() + { + sem.wait(); + } + + bool tryWait() + { + return sem.tryWait(); + } + + bool timedWait(int usecs) + { + return sem.wait(dur!"usecs"(usecs)); + } + + void post() + { + sem.notify(); + } + + void destroy() + { + Mallocator.instance.dispose(sem); + } + } + + struct Thread + { + alias DG = void delegate(); + + DG threadStart; + D_Thread thread; + + void start(DG dg) + { + thread = Mallocator.instance.make!D_Thread(dg); + thread.start(); + } + + void join() + { + thread.join(); + } + } +} + +////////////////////////////////////////////// +///////////////// ThreadPool ///////////////// +////////////////////////////////////////////// + +private enum gMaxThreadsNum = 128; + +alias JobDelegate = void delegate(ThreadData*, JobData*); + +// Structure to store job start and end time +struct JobLog +{ + string name; /// Name of job + ulong time; /// Time started (us) + ulong duration; /// Took time (us) +} + +/// First in first out queue with atomic lock +struct JobQueue +{ + alias LockType = long; + align(64) shared LockType lock; /// Lock for accesing list of Jobs + align(64) JobData* first; /// Fist element in list of Jobs + + /// Check if empty without locking, doesn't give guarantee that list is truly empty + bool emptyRaw() + { + bool isEmpty = first == null; + return isEmpty; + } + + /// Check if empty + bool empty() + { + while (!cas(&lock, cast(LockType) false, cast(LockType) true)) + instructionPause(); + + bool isEmpty = first == null; + atomicStore!(MemoryOrder.rel)(lock, cast(LockType) false); + return isEmpty; + } + + /// Add job to queue + void add(JobData* t) + { + while (!cas(&lock, cast(LockType) false, cast(LockType) true)) + instructionPause(); + + t.next = first; + first = t; + + atomicStore!(MemoryOrder.rel)(lock, cast(LockType) false); + } + + /// Add range of jobs to queue + void addRange(Range)(Range arr) + { + if (arr.length == 0) + return; + + JobData* start = arr[0]; + JobData* last = start; + + foreach (t; arr[1 .. $]) + { + last.next = t; + last = t; + } + + while (!cas(&lock, cast(LockType) false, cast(LockType) true)) + instructionPause(); + last.next = first; + first = start; + atomicStore!(MemoryOrder.rel)(lock, cast(LockType) false); + } + + /// Pop job from queue + JobData* pop() + { + while (!cas(&lock, cast(LockType) false, cast(LockType) true)) + instructionPause(); + + if (first == null) + { + atomicStore!(MemoryOrder.rel)(lock, cast(LockType) false); + return null; + } + + JobData* result = first; + first = first.next; + + atomicStore!(MemoryOrder.rel)(lock, cast(LockType) false); + return result; + } + +} + +/// Structure containing job data +/// JobData memory is allocated by user +/// JobData lifetime is managed by user +/// JobData has to live as long as it's group or end of job execution +/// JobData fields can be changed in del delegate and job can be added to thread pool again, to continue execution (call same function again or another if del was changed) +struct JobData +{ + JobDelegate del; /// Delegate to execute + string name; /// Name of job + private JobsGroup* group; /// Group to which this job belongs + private align(64) JobData* next; /// JobData makes a list of jobs to be done by thread +} + +/// Structure responsible for thread in thread pool +/// Stores jobs to be executed by this thread (jobs can be stolen by another thread) +/// Stores cache for logs +struct ThreadData +{ +public: + ThreadPool* threadPool; /// Pool this thread belongs to + int threadId; /// Thread id. Valid only for this thread pool + + /// Function starting execution of thread main loop + /// External threads can call this function to start executing jobs + void threadStartFunc() + { + //end = false; + threadFunc(&this); + } + +private: + JobQueue jobsQueue; /// Queue of jobs to be done, jobs can be stolen from another thread + JobQueue jobsExclusiveQueue; /// Queue of jobs to be done, jobs can't be stolen + align(64) Semaphore semaphore; /// Semaphore to wake/sleep this thread + align(64) Thread thread; /// Systemn thread handle + JobLog[] logs; /// Logs cache + int lastLogIndex = -1; /// Last created log index + int jobsDoneCount; + + shared bool end; /// Check if thread has to exit. Thread will exit only if end is true and jobsToDo is empty + shared bool acceptJobs; /// Check if thread should accept new jobs, If false thread won't steal jobs from other threads and will sleep longer if queue js empty + bool externalThread; /// Thread not allocated by thread pool + +} + +/// Thread Pool +/// Manages bounch of threads to execute given jobs as quickly as possible +/// There are no priorities beetween jobs. Jobs added to queues in same order as they are in slices, but due to job stealing and uneven speed of execution beetween threads jobs execution order is unspecified. +/// Number of threads executing jobs can be dynamically changed in any time. Threads removed from execution will work until the end of the program but shouldn't accept new jobs. +struct ThreadPool +{ + alias FlushLogsDelegaste = void delegate(ThreadData* threadData, JobLog[] logs); /// Type of delegate to flush logs + FlushLogsDelegaste onFlushLogs; /// User custom delegate to flush logs, if overriden defaultFlushLogs will be used. Can be sset after initialize() call + int logsCacheNum; /// Number of log cache entries. Should be set before setThreadsNum is called +private: + ThreadData*[gMaxThreadsNum] threadsData; /// Data for threads + align(64) shared int threadsNum; /// Number of threads currentlu accepting jobs + align(64) shared bool threadsDataLock; /// Any modification of threadsData array (change in size or pointer modification) had to be locked + align(64) shared int threadSelector; /// Index of thread to which add next job + FILE* logFile; /// File handle for defaultFlushLogs log file + JobData[4] resumeJobs; /// Dummu jobs to resume some thread + +public: + int jobsDoneCount() + { + int sum; + foreach (i, ref ThreadData* th; threadsData) + { + if (th is null) + continue; + + sum += th.jobsDoneCount; + } + return sum; + } + + void jobsDoneCountReset() + { + foreach (i, ref ThreadData* th; threadsData) + { + if (th is null) + continue; + th.jobsDoneCount = 0; + } + } + /// Initialize thread pool + void initialize() + { + + foreach (ref JobData j; resumeJobs) + j = JobData(&dummyJob, "Dummy-Resume"); + + version (MM_NO_LOGS) + { + logsCacheNum = 0; + } + else + { + onFlushLogs = &defaultFlushLogs; + logsCacheNum = 1024; + + logFile = fopen("trace.json", "w"); + fprintf(logFile, "["); + fclose(logFile); + logFile = fopen("trace.json", "a"); + assert(logFile !is null); + } + } + + /// Clean ups ThreadPool + ~this() + { + version (MM_NO_LOGS) + { + + } + else if (logFile) + { + fclose(logFile); + logFile = null; + } + + + } + + /// Registers external thread to thread pool array. There will be allocated data for this thread and it will have specified id + /// External threads are not joined at the end of thread pool execution + /// Returns ThreadData corresponding to external thread. To acually start executing, external thread had to call threadStartFunc() from returned variable + ThreadData* registerExternalThread() + { + lockThreadsData(); + //scope (exit) + + + ThreadData* threadData = makeThreadData(); + threadData.threadPool = &this; + threadData.semaphore.initialize(); + threadData.externalThread = true; + threadData.acceptJobs = true; + + int threadNum = atomicOp!"+="(threadsNum, 1) - 1; + + threadData.threadId = threadNum; + + threadsData[threadNum] = threadData; + + unlockThreadsData(); + + return threadData; + } + + /// Unregisters external thread. Can be called only when external thread have left the thread pool + void unregistExternalThread(ThreadData* threadData) + { + lockThreadsData(); + scope (exit) + unlockThreadsData(); + + disposeThreadData(threadData); + } + + /// Allows external threads to return from threadStartFunc + void releaseExternalThreads() + { + lockThreadsData(); + scope (exit) + unlockThreadsData(); + + // Release external threads (including main thread) + foreach (i, ref ThreadData* th; threadsData) + { + if (th is null) + continue; + if (!th.externalThread) + continue; + + auto rng = resumeJobs[].map!((ref a) => &a); + addJobsRange(rng, cast(int) i); + atomicStore(th.end, true); + } + } + + /// Waits for all threads to finish and joins them (excluding external threads) + void waitThreads() + { + lockThreadsData(); + scope (exit) + unlockThreadsData(); + foreach (i, ref ThreadData* th; threadsData) + { + if (th is null) + continue; + + atomicStore(th.acceptJobs, false); + atomicStore(th.end, true); + } + foreach (i, ref ThreadData* th; threadsData) + { + if (th is null || th.externalThread) + continue; + + th.thread.join(); + disposeThreadData(th); + } + } + + /// Sets number of threads to accept new jobs + /// If there were never so much threads created, they will be created + /// If number of threads set is smaller than there was threads before, they are not joined but they stop getting new jobs, they stop stealing jobs and they sleep longer + /// Locking operation + void setThreadsNum(int num) + { + assert(num <= gMaxThreadsNum); + assert(num > 0); + + lockThreadsData(); + scope (exit) + unlockThreadsData(); + + foreach (i, ref ThreadData* th; threadsData) + { + if (th) + { + // Exists but has to be disabled + atomicStore(th.acceptJobs, i < num); + continue; + } + else if (i >= num) + { + // Doesn't exist and is not required + continue; + } + // Doesn't exist and is required + th = makeThreadData(); + th.threadPool = &this; + th.threadId = cast(int) i; + th.acceptJobs = true; + th.semaphore.initialize(); + + th.thread.start(&th.threadStartFunc); + } + + atomicStore(threadsNum, num); + + } + + /// Adds job to be executed by thread pool, such a job won't be synchronized with any group or job + /// If threadNum is different than -1 only thread with threadNum will be able to execute given job + /// It is advised to use synchronized group of jobs + void addJobAsynchronous(JobData* data, int threadNum = -1) + { + if (threadNum == -1) + { + ThreadData* threadData = getThreadDataToAddJobTo(); + threadData.jobsQueue.add(data); + threadData.semaphore.post(); + return; + } + ThreadData* threadData = threadsData[threadNum]; + assert(threadData !is null); + threadData.jobsExclusiveQueue.add(data); + threadData.semaphore.post(); + } + + /// Adds job to be executed by thread pool, group specified in group data won't be finished until this job ends + /// If threadNum is different than -1 only thread with threadNum will be able to execute given job + void addJob(JobData* data, int threadNum = -1) + { + assert(data.group); + atomicOp!"+="(data.group.jobsToBeDoneCount, 1); + addJobAsynchronous(data, threadNum); + } + + /// Adds multiple jobs at once + /// Range has to return JobData* + /// Range has to have length property + /// Range is used so there is no need to allocate JobData*[] + /// All jobs has to belong to one group + /// If threadNum is different than -1 only thread with threadNum will be able to execute given jobs + void addJobsRange(Range)(Range rng, int threadNum = -1) + { + if (threadNum != -1) + { + ThreadData* threadData = threadsData[threadNum]; + assert(threadData !is null); + threadData.jobsExclusiveQueue.addRange(rng); + foreach (sInc; 0 .. rng.length) + threadData.semaphore.post(); + + return; + } + + if (rng.length == 0) + { + return; + } + + foreach (JobData* threadData; rng) + { + assert(rng[0].group == threadData.group); + } + atomicOp!"+="(rng[0].group.jobsToBeDoneCount, cast(int) rng.length); + int threadsNumLocal = threadsNum; + int part = cast(int) rng.length / threadsNumLocal; + if (part > 0) + { + foreach (i, ThreadData* threadData; threadsData[0 .. threadsNumLocal]) + { + auto slice = rng[i * part .. (i + 1) * part]; + threadData.jobsQueue.addRange(slice); + + foreach (sInc; 0 .. part) + threadData.semaphore.post(); + + } + rng = rng[part * threadsNumLocal .. $]; + } + foreach (i, ThreadData* threadData; threadsData[0 .. rng.length]) + { + threadData.jobsQueue.add(rng[i]); + threadData.semaphore.post(); + } + + } + + /// Adds group of jobs to threadPool, group won't be synchronized + void addGroupAsynchronous(JobsGroup* group) + { + group.thPool = &this; + if (group.jobs.length == 0) + { + // Immediately call group end + group.onGroupFinish(); + return; + } + + group.setUpJobs(); + auto rng = group.jobs[].map!((ref a) => &a); + addJobsRange(rng, group.executeOnThreadNum); + } + + /// Adds group of jobs to threadPool + /// Spwaning group will finish after this group have finished + void addGroup(JobsGroup* group, JobsGroup* spawnedByGroup) + { + assert(spawnedByGroup); + group.spawnedByGroup = spawnedByGroup; + atomicOp!"+="(spawnedByGroup.jobsToBeDoneCount, 1); // Increase by one, so 'spawning group' will wait for 'newly added group' to finish + addGroupAsynchronous(group); // Synchronized by jobsToBeDoneCount atomic variable + } + + /// Explicitly calls onFlushLogs on all threads + void flushAllLogs() + { + lockThreadsData(); + scope (exit) + unlockThreadsData(); + foreach (thNum; 0 .. atomicLoad(threadsNum)) + { + ThreadData* th = threadsData[thNum]; + onThreadFlushLogs(th); + } + + foreach (i, ref ThreadData* th; threadsData) + { + if (th is null) + continue; + + onThreadFlushLogs(th); + } + } + + /// Default implementation of flushing logs + /// Saves logs to trace.json file in format acceptable by Google Chrome tracking tool chrome://tracing/ + /// Logs can be watched even if apllication crashed, but might require removing last log entry from trace.json + void defaultFlushLogs(ThreadData* threadData, JobLog[] logs) + { + version (MM_NO_LOGS) + { + } + else + { + // (log rows num) * (static json length * time length * duration length) + long start = useconds(); + size_t size = (logs.length + 1) * (128 + 20 + 20); + size_t used = 0; + + foreach (ref log; logs) + { + size += log.name.length; // size of name + } + + char* buffer = cast(char*) malloc(size); + + foreach (ref log; logs) + { + + size_t charWritten = snprintf(buffer + used, size - used, + `{"name":"%s", "pid":1, "tid":%lld, "ph":"X", "ts":%lld, "dur":%lld }, %s`, + log.name.ptr, threadData.threadId + 1, log.time, log.duration, "\n".ptr); + used += charWritten; + } + + long end = useconds(); + size_t charWritten = snprintf(buffer + used, size - used, + `{"name":"logFlush", "pid":1, "tid":%lld, "ph":"X", "ts":%lld, "dur":%lld }, %s`, + threadData.threadId + 1, start, end - start, "\n".ptr); + used += charWritten; + fwrite(buffer, 1, used, logFile); + } + } + +private: + /// Atomic lock + void lockThreadsData() + { + // Only one thread at a time can change threads number in a threadpool + while (!cas(&threadsDataLock, false, true)) + { + } + } + + /// Atomic unlock + void unlockThreadsData() + { + atomicStore(threadsDataLock, false); + } + + /// Allocate ThreadData + ThreadData* makeThreadData() + { + ThreadData* threadData = makeVar!ThreadData(); + threadData.logs = makeVarArray!(JobLog)(logsCacheNum); + return threadData; + } + + /// Dispose ThreadData + void disposeThreadData(ThreadData* threadData) + { + disposeArray(threadData.logs); + return disposeVar(threadData); + } + + /// Get thread most suiting to add job to + ThreadData* getThreadDataToAddJobTo() + { + int threadNum = atomicOp!"+="(threadSelector, 1); + + foreach (i; 0 .. 1_000) + { + if (threadNum >= threadsNum) + { + threadNum = 0; + atomicStore(threadSelector, 0); + } + ThreadData* threadData = threadsData[threadNum]; + if (threadData != null) + { + return threadData; + } + threadNum++; + } + assert(0); + } + + /// Create log on start of job + void onStartJob(JobData* data, ThreadData* threadData) + { + + threadData.jobsDoneCount++; + version (MM_NO_LOGS) + { + } + else + { + if (cast(int) threadData.logs.length <= 0) + { + return; + } + if (threadData.lastLogIndex >= cast(int) threadData.logs.length - 1) + { + onThreadFlushLogs(threadData); + } + + threadData.lastLogIndex++; + + JobLog log; + log.name = data.name; + log.time = useconds(); + threadData.logs[threadData.lastLogIndex] = log; + } + } + + /// Set log finish time on end of job + void onEndJob(JobData* data, ThreadData* threadData) + { + version (MM_NO_LOGS) + { + } + else + { + if (cast(int) threadData.logs.length <= 0) + { + return; + } + assert(threadData.lastLogIndex < threadData.logs.length); + JobLog* log = &threadData.logs[threadData.lastLogIndex]; + log.duration = useconds() - log.time; + } + } + + /// Flush logs + void onThreadFlushLogs(ThreadData* threadData) + { + /*scope (exit) + { + threadData.lastLogIndex = -1; + }*/ + + assert(threadData); + + if (threadData.lastLogIndex < 0 || onFlushLogs is null) + { + return; + } + + onFlushLogs(threadData, threadData.logs[0 .. threadData.lastLogIndex + 1]); + + threadData.lastLogIndex = -1; + } + + /// Does nothing + void dummyJob(ThreadData* threadData, JobData* data) + { + + } + + /// Steal job from another thread + JobData* stealJob(int threadNum) + { + foreach (thSteal; 0 .. atomicLoad(threadsNum)) + { + if (thSteal == threadNum) + continue; // Do not steal from requesting thread + + ThreadData* threadData = threadsData[thSteal]; + + if (threadData is null || !threadData.semaphore.tryWait()) + continue; + + JobData* data = threadData.jobsQueue.pop(); + + if (data is null) + threadData.semaphore.post(); + + return data; + } + return null; + } +} + +/// Adding groups of jobs is faster and groups can have dependencies between each other +struct JobsGroup +{ +public: + string name; /// Name of group + JobData[] jobs; /// Jobs to be executed by this group, jobs have to live as long as group lives + void delegate(JobsGroup* group) onFinish; // Delegate called when group will finish, can be used to free memory + ThreadPool* thPool; /// Thread pool of this group + int executeOnThreadNum = -1; /// Thread num to execute jobs on + + this(string name, JobData[] jobs = [], int executeOnThreadNum = -1) + { + this.name = name; + this.jobs = jobs; + this.executeOnThreadNum = executeOnThreadNum; + jobsToBeDoneCount = 0; + } + + ~this() nothrow + { + free(children.ptr); + children = null; + } + + /// Make this group dependant from another group + /// Dependant group won't start untill its dependencies will be fulfilled + void dependantOn(JobsGroup* parent) + { + size_t newLen = parent.children.length + 1; + JobsGroup** ptr = cast(JobsGroup**) realloc(parent.children.ptr, + newLen * (JobsGroup*).sizeof); + parent.children = ptr[0 .. newLen]; + parent.children[$ - 1] = &this; + // parent.children ~= &this; + atomicOp!"+="(dependenciesWaitCount, 1); + } + + /// Returns number of dependencies this group is waiting for + int getDependenciesWaitCount() + { + return atomicLoad(dependenciesWaitCount); + } + +private: + JobsGroup* spawnedByGroup; /// Group which spawned this group, if present spwaning group is waiting for this group to finish + JobsGroup*[] children; /// Groups depending on this group + align(64) shared int dependenciesWaitCount; /// Count of dependencies this group waits for + align(64) shared int jobsToBeDoneCount; /// Number of this group jobs still executing + + /// Checks if depending groups or spawning group have to be started + /// Executes user onFinish function + void onGroupFinish() + { + + decrementChildrendependencies(); + if (spawnedByGroup) + { + auto num = atomicOp!"-="(spawnedByGroup.jobsToBeDoneCount, 1); + if (num == 0) + { + spawnedByGroup.onGroupFinish(); + } + } + if (onFinish) + onFinish(&this); + } + + /// Check if decrement dependencies counter and start them if theirs dependencies are fulfilled + void decrementChildrendependencies() + { + foreach (JobsGroup* group; children) + { + auto num = atomicOp!"-="(group.dependenciesWaitCount, 1); + assert(num >= 0); + if (num == 0) + { + thPool.addGroupAsynchronous(group); // All dependencies of this group are fulfilled, so is already synchronized + } + } + } + /// Prepare jobs data for adding to thread pool + void setUpJobs() + { + foreach (i; 0 .. jobs.length) + { + jobs[i].group = &this; + } + } + +} + +/// Main function executed by thread present in thread pool +/// Executes functions from its own queue +/// If there are no jobs in its queue, steals from another thread +/// If there is nothing to steal, sleeps on its semaphore for a while (stage when cpu is not used) +/// Sleep time is longer for jobs not accepting jobs, they don't exit because it is hard to guarantee that nobody is adding to them some job (thread might exit but job will be added anyway and application will malfunctio +/// Thread end only when it's queue is empty. Jobs shouldn't be added to queue after ThreadPool.waitThreads() call +private void threadFunc(ThreadData* threadData) +{ + ThreadPool* threadPool = threadData.threadPool; + int threadNum = threadData.threadId; + + while (!atomicLoad!(MemoryOrder.raw)(threadData.end) + || !threadData.jobsQueue.empty() || !threadData.jobsExclusiveQueue.empty()) + { + JobData* data; + if (threadData.semaphore.tryWait()) + { + if (!threadData.jobsExclusiveQueue.emptyRaw()) + data = threadData.jobsExclusiveQueue.pop(); + + if (data is null) + data = threadData.jobsQueue.pop(); + + if (data is null) + threadData.semaphore.post(); + + assert(data !is null); + } + else + { + bool acceptJobs = atomicLoad!(MemoryOrder.raw)(threadData.acceptJobs); + if (acceptJobs) + { + data = threadPool.stealJob(threadNum); + } + + if (data is null) + { + // Thread does not have own job and can not steal it, so wait for a job + bool ok = threadData.semaphore.timedWait(1_000 + !acceptJobs * 10_000); + if (ok) + { + + if (!threadData.jobsExclusiveQueue.emptyRaw()) + data = threadData.jobsExclusiveQueue.pop(); + + if (data is null) + data = threadData.jobsQueue.pop(); + + if (data is null) + threadData.semaphore.post(); + } + } + } + + // Nothing to do + if (data is null) + { + continue; + } + + // Do the job + threadPool.onStartJob(data, threadData); + data.del(threadData, data); + threadPool.onEndJob(data, threadData); + if (data.group) + { + auto num = atomicOp!"-="(data.group.jobsToBeDoneCount, 1); + if (num == 0) + { + data.group.onGroupFinish(); + } + } + + } + threadData.end = false; + assert(threadData.jobsQueue.empty()); +} + +////////////////////////////////////////////// +//////////////////// Test //////////////////// +////////////////////////////////////////////// +/* +void testThreadPool() +{ + enum jobsNum = 1024 * 4; + + ThreadPool thPool; + thPool.initialize(); + + ThreadData* mainThread = thPool.registerExternalThread(); // Register main thread as thread 0 + JobData startFrameJobData; // Variable to store job starting the TestApp + + JobData[jobsNum] frameJobs; // Array to store jobs created in TestApp.continueFrameInOtherJob + shared int frameNum; // Simulate game loop, run jobs for few frames and exit + + // App starts as one job &startFrame + // Then using own JobData memory spawns 'continueFrameInOtherJob' job + // 'continueFrameInOtherJob' job fills frameJobs array with &importantTask jobs. Group created to run this jobs is freed using JobsGroup.onFinish delegate + // 'importantTask' allocate new jobs (&importantTaskSubTask) and group, they all deallocated using JobsGroup.onFinish delegate + // 'continueFrameInOtherJob' waits for all 'importantTask'. All 'importantTask' wait for all 'importantTaskSubTask'. + // So after all 'importantTaskSubTask' and 'importantTask' are done 'continueFrameInOtherJob' ends and spawns &finishFrame + // 'finishFrame' spawn new frame or exits application + struct TestApp + { + // First job in frame + // Do some stuff and spawn some other job + // 1 - Number of jobs of this kind in frame + void startFrame(ThreadData* threadData, JobData* startFrameJobData) + { + startFrameJobData.del = &continueFrameInOtherJobAAA; + startFrameJobData.name = "cont frmAAA"; + thPool.addJobAsynchronous(startFrameJobData, thPool.threadsNum - 1); /// startFrame is the only job in thread pool no synchronization is required + } + + void continueFrameInOtherJobAAA(ThreadData* threadData, JobData* startFrameJobData) + { + + static struct JobGroupMemory + { + JobsGroup[6] groups; + JobData[1][6] groupsJobs; + TestApp* app; + JobData* startFrameJobData; + + void spawnCont(JobsGroup* group) + { + // startFrameJobData.del = &continueFrameInOtherJob; + startFrameJobData.del = &app.finishFrame; + startFrameJobData.name = "cont frm"; + group.thPool.addJobAsynchronous(startFrameJobData); /// startFrame is the only job in thread pool no synchronization is required + + } + } + + JobGroupMemory* memory = makeVar!JobGroupMemory(); + memory.app = &this; + memory.startFrameJobData = startFrameJobData; + + with (memory) + { + groups[0] = JobsGroup("dependant 0", groupsJobs[0]); + groups[1] = JobsGroup("dependant 1", groupsJobs[1]); + groups[2] = JobsGroup("dependant 2", groupsJobs[2]); + groups[3] = JobsGroup("dependant 3", groupsJobs[3]); + groups[4] = JobsGroup("dependant 4", groupsJobs[4]); + groups[5] = JobsGroup("dependant 5", groupsJobs[5]); + groups[5].onFinish = &spawnCont; + + groups[2].dependantOn(&groups[0]); + groups[2].dependantOn(&groups[1]); + + groups[3].dependantOn(&groups[0]); + groups[3].dependantOn(&groups[1]); + groups[3].dependantOn(&groups[2]); + + groups[4].dependantOn(&groups[1]); + groups[4].dependantOn(&groups[3]); + + groups[5].dependantOn(&groups[0]); + groups[5].dependantOn(&groups[1]); + groups[5].dependantOn(&groups[2]); + groups[5].dependantOn(&groups[3]); + groups[5].dependantOn(&groups[4]); + + foreach (ref jobs; groupsJobs) + foreach (ref j; jobs) + j = JobData(&this.importantTaskSubTask, "n"); + + thPool.addGroupAsynchronous(&groups[0]); + thPool.addGroupAsynchronous(&groups[1]); + } + } + + // Job for some big system + // Spawns some jobs and when they are done spawns finishFrame job + // 1 - Number of jobs of this kind in frame + void continueFrameInOtherJob(ThreadData* threadData, JobData* startFrameJobData) + { + static struct JobGroupMemory + { + JobsGroup group; + TestApp* app; + JobData* startFrameJobData; + + void freeAndContinue(JobsGroup* group) + { + startFrameJobData.del = &app.finishFrame; + startFrameJobData.name = "finishFrame"; + group.thPool.addJobAsynchronous(startFrameJobData, group.thPool.threadsNum - 1); /// startFrameJobData is continuation of 'startFrame data', all important jobs finished so it is the only job, no synchronization required. Always spawn on last thread + disposeVar!(JobGroupMemory)(&this); + } + } + + JobGroupMemory* important = makeVar!JobGroupMemory(); + important.app = &this; + important.startFrameJobData = startFrameJobData; + + foreach (ref j; frameJobs) + j = JobData(&this.importantTask, "vip"); + + important.group = JobsGroup("a lot of jobs", frameJobs[]); + important.group.onFinish = &important.freeAndContinue; + + thPool.addGroupAsynchronous(&important.group); // No Synchronization required continueFrameInOtherJob is the only job + } + + // Some task which by itself does a lot of computation so it spawns few more jobs + // jobsNum - Number of jobs of this kind in frame + void importantTask(ThreadData* threadData, JobData* data) + { + // All tasks created here will, make 'importantTask' wait with finish untill this jobs will finish + + /// Add 10 tasks in group + static struct JobGroupMemory + { + JobsGroup group; + JobData[128] jobs; + + void freeMee(JobsGroup* group) + { + disposeVar!(JobGroupMemory)(&this); + } + } + + JobGroupMemory* subGroup = makeVar!JobGroupMemory(); + + foreach (ref j; subGroup.jobs) + j = JobData(&this.importantTaskSubTask, "vip sub"); + + subGroup.group = JobsGroup("128 jobs", subGroup.jobs[]); + subGroup.group.onFinish = &subGroup.freeMee; + thPool.addGroup(&subGroup.group, data.group); + + /// Add single tasks + data.del = &importantTaskSubTask; + data.name = "sub"; + thPool.addJob(data); + } + + // Job which simply does some work + // jobsNum * 128 - Number of jobs of this kind in frame + void importantTaskSubTask(ThreadData* threadData, JobData* data) + { + } + + // Finish frame + // 1 - Number of jobs of this kind in frame + void finishFrame(ThreadData* threadData, JobData* startFrameJobData) + { + auto num = atomicOp!"+="(frameNum, 1); + if (num == 10) + { + thPool.releaseExternalThreads(); // After 10 frames exit application + return; + } + *startFrameJobData = JobData(&startFrame, "StartFrame"); // + thPool.addJobAsynchronous(startFrameJobData); // Start next frame, there should't be any other tasks execept of this one, so no synchronization is required + + } + + // Func to test if dynamic changing of threads number works + // void changeThreadsNum() + // { + // import std.random : uniform; + + // bool change = uniform(0, 100) == 3; + // if (!change) + // return; + + // int threadsNum = uniform(3, 5); + // thPool.setThreadsNum(threadsNum); + + // } + } + + void testThreadsNum(int threadsNum) + { + frameNum = 0; + thPool.jobsDoneCountReset(); + thPool.setThreadsNum(threadsNum); + + TestApp testApp = TestApp(); + startFrameJobData = JobData(&testApp.startFrame, "StartFrame"); // Start first frame, will live as long as main thread won't exit from threadStartFunc() + + ulong start = useconds(); + thPool.addJobAsynchronous(&startFrameJobData); // Synchronization is made by groupEnd (last job in pool) which calls thPool.releaseExternalThreads(); + mainThread.threadStartFunc(); + ulong end = useconds(); + printf("Threads Num: %2d. Jobs: %d. Time: %5.2f ms. jobs/ms: %5.2f\n", threadsNum, thPool.jobsDoneCount, + (end - start) / 1000.0f, thPool.jobsDoneCount / ((end - start) / 1000.0f)); + } + + while (1) + { + // foreach (i; 1 .. 32) + // testThreadsNum(i); + + testThreadsNum(1); + testThreadsNum(4); + testThreadsNum(16); + } + thPool.flushAllLogs(); + thPool.waitThreads(); + thPool.unregistExternalThread(mainThread); +} + +version (D_BetterC) +{ + + extern (C) int main(int argc, char*[] argv) // for betterC + { + testThreadPool(); + return 0; + } +} +else +{ + int main() + { + testThreadPool(); + return 0; + } +}//*/ +// Compile +// -fsanitize=address +// rdmd -g -of=thread_pool src/mmutils/thread_pool.d && ./thread_pool +// ldmd2 -release -inline -checkaction=C -g -of=thread_pool src/mmutils/thread_pool.d && ./thread_pool +// ldmd2 -checkaction=C -g -of=thread_pool src/mmutils/thread_pool.d && ./thread_pool \ No newline at end of file diff --git a/demos/external/imports/bindbc/sdl/bind/package.d b/demos/external/wasm_imports/bindbc/sdl/bind/package.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/package.d rename to demos/external/wasm_imports/bindbc/sdl/bind/package.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdl.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdl.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdl.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdl.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlassert.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlassert.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlassert.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlassert.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlaudio.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlaudio.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlaudio.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlaudio.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlblendmode.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlblendmode.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlblendmode.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlblendmode.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlclipboard.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlclipboard.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlclipboard.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlclipboard.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlcpuinfo.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlcpuinfo.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlcpuinfo.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlcpuinfo.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlerror.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlerror.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlerror.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlerror.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlevents.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlevents.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlevents.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlevents.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlfilesystem.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlfilesystem.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlfilesystem.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlfilesystem.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlgamecontroller.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlgamecontroller.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlgamecontroller.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlgamecontroller.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlgesture.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlgesture.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlgesture.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlgesture.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlhaptic.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlhaptic.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlhaptic.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlhaptic.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlhints.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlhints.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlhints.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlhints.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdljoystick.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdljoystick.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdljoystick.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdljoystick.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlkeyboard.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlkeyboard.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlkeyboard.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlkeyboard.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlkeycode.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlkeycode.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlkeycode.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlkeycode.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlloadso.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlloadso.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlloadso.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlloadso.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdllog.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdllog.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdllog.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdllog.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlmessagebox.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlmessagebox.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlmessagebox.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlmessagebox.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlmouse.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlmouse.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlmouse.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlmouse.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlpixels.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlpixels.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlpixels.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlpixels.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlplatform.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlplatform.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlplatform.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlplatform.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlpower.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlpower.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlpower.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlpower.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlrect.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlrect.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlrect.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlrect.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlrender.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlrender.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlrender.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlrender.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlrwops.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlrwops.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlrwops.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlrwops.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlscancode.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlscancode.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlscancode.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlscancode.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlshape.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlshape.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlshape.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlshape.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlstdinc.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlstdinc.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlstdinc.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlstdinc.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlsurface.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlsurface.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlsurface.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlsurface.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlsystem.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlsystem.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlsystem.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlsystem.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlsyswm.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlsyswm.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlsyswm.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlsyswm.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdltimer.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdltimer.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdltimer.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdltimer.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdltouch.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdltouch.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdltouch.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdltouch.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlversion.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlversion.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlversion.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlversion.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlvideo.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlvideo.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlvideo.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlvideo.d diff --git a/demos/external/imports/bindbc/sdl/bind/sdlvulkan.d b/demos/external/wasm_imports/bindbc/sdl/bind/sdlvulkan.d similarity index 100% rename from demos/external/imports/bindbc/sdl/bind/sdlvulkan.d rename to demos/external/wasm_imports/bindbc/sdl/bind/sdlvulkan.d diff --git a/demos/external/imports/bindbc/sdl/config.d b/demos/external/wasm_imports/bindbc/sdl/config.d similarity index 100% rename from demos/external/imports/bindbc/sdl/config.d rename to demos/external/wasm_imports/bindbc/sdl/config.d diff --git a/demos/external/imports/bindbc/sdl/dynload.d b/demos/external/wasm_imports/bindbc/sdl/dynload.d similarity index 100% rename from demos/external/imports/bindbc/sdl/dynload.d rename to demos/external/wasm_imports/bindbc/sdl/dynload.d diff --git a/demos/external/imports/bindbc/sdl/image.d b/demos/external/wasm_imports/bindbc/sdl/image.d similarity index 100% rename from demos/external/imports/bindbc/sdl/image.d rename to demos/external/wasm_imports/bindbc/sdl/image.d diff --git a/demos/external/imports/bindbc/sdl/mixer.d b/demos/external/wasm_imports/bindbc/sdl/mixer.d similarity index 100% rename from demos/external/imports/bindbc/sdl/mixer.d rename to demos/external/wasm_imports/bindbc/sdl/mixer.d diff --git a/demos/external/imports/bindbc/sdl/package.d b/demos/external/wasm_imports/bindbc/sdl/package.d similarity index 100% rename from demos/external/imports/bindbc/sdl/package.d rename to demos/external/wasm_imports/bindbc/sdl/package.d diff --git a/demos/external/imports/bindbc/sdl/ttf.d b/demos/external/wasm_imports/bindbc/sdl/ttf.d similarity index 100% rename from demos/external/imports/bindbc/sdl/ttf.d rename to demos/external/wasm_imports/bindbc/sdl/ttf.d diff --git a/demos/simple/source/app.d b/demos/simple/source/app.d deleted file mode 100644 index d8d61f5..0000000 --- a/demos/simple/source/app.d +++ /dev/null @@ -1,216 +0,0 @@ -module source.app; - -import ecs.std; -import ecs.core; -import ecs.manager; -import ecs.attributes; -import ecs.entity; - -import bindbc.sdl; - -import utils.utils; -import utils.texture; - -import ecs_utils.math.vector; - -version (WebAssembly) -{ - extern (C) void _start() - { - } -} - -SDL_Renderer *renderer; -SDL_Window* window; -Texture texture; -EntityManager* manager; - -struct CLocation -{ - mixin ECS.Component; - - alias location this; - - vec2 location; -} - -struct CTexture -{ - mixin ECS.Component; - - Texture tex; -} - -struct DrawSystem -{ - mixin ECS.System; - - struct EntitiesData - { - uint length; - @readonly CTexture[] textures; - @readonly CLocation[] locations; - } - - void onUpdate(EntitiesData data) - { - foreach(i; 0..data.length) - { - draw(renderer, data.textures[i].tex, data.locations[i], vec2(32,32), vec4(0,0,1,1)); - } - } -} - -struct MoveSystem -{ - mixin ECS.System; - - struct EntitiesData - { - uint length; - CLocation[] locations; - } - - void onUpdate(EntitiesData data) - { - foreach(i; 0..data.length) - { - data.locations[i].location.y = data.locations[i].location.y + 1; - if(data.locations[i].location.y > 400)data.locations[i].location.y = 0; - } - } -} - -extern (C) int main(int argc, char** argv) -{ - fps = 0; - time = 0; - - if (SDL_Init(SDL_INIT_VIDEO) < 0) - { - printf("SDL could not initialize! SDL_Error: %s", SDL_GetError()); - return -1; - } - - SDL_version sdl_version; - SDL_GetVersion(&sdl_version); - printf("SDL version: %u.%u.%u\n",cast(uint)sdl_version.major,cast(uint)sdl_version.minor,cast(uint)sdl_version.patch); - - SDL_Window* window = SDL_CreateWindow("Simple", SDL_WINDOWPOS_CENTERED, - SDL_WINDOWPOS_CENTERED, 600, 400, SDL_WINDOW_SHOWN); - //SDL_CreateWindowAndRenderer(600, 400, SDL_RENDERER_ACCELERATED, &window, &renderer); - renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC); - SDL_SetRenderDrawColor(renderer, 1, 255, 255, 255); - - texture.create(); - texture.load(renderer, "assets/textures/buckler.png"); - - EntityManager.initialize(8); - manager = EntityManager.instance; - - manager.beginRegister(); - - manager.registerComponent!CLocation; - manager.registerComponent!CTexture; - - manager.registerSystem!MoveSystem(64); - manager.registerSystem!DrawSystem(64); - - manager.endRegister(); - - ushort[2] components = [CLocation.component_id, CTexture.component_id]; - EntityTemplate* tmpl = manager.allocateTemplate(components); - CTexture* tex_comp = tmpl.getComponent!CTexture; - tex_comp.tex = texture; - CLocation* loc_comp = tmpl.getComponent!CLocation; - // loc_comp.location = vec2(64,64); - - foreach(i; 0..10) - foreach(j; 0..10) - { - loc_comp.location = vec2(i*32+64,j*32+64); - manager.addEntity(tmpl); - } - - - manager.freeTemplate(tmpl); - - /*image = IMG_Load("assets/owl.png"); - tex = SDL_CreateTextureFromSurface(renderer, image);*/ - - version(WebAssembly) - { - emscripten_set_main_loop_arg(&loop, null, -1, 1); - } - - bool arg = true; - while(arg == true) - { - loop(&arg); - } - - if (window !is null) { - SDL_DestroyWindow(window); - } - - end(); - - return 0; -} - -long time; -uint fps; - -extern(C) void loop(void *arg = null) -{ - static float fps_time = 0; - float delta_time = cast(float)(Time.getUSecTime() - time); - if(delta_time > 1000_000)delta_time = 1000; - time = Time.getUSecTime(); - - if(fps_time < 0)fps_time = 0; - - fps++; - fps_time += delta_time; - if(fps_time > 1000_000) - { - - printf("FPS: %u\n",fps); - fps = 0; - fps_time -= 1000_000; - } - - SDL_Event event; - while (SDL_PollEvent(&event)) - { - if (event.type == SDL_QUIT) { - version(WebAssembly)emscripten_cancel_main_loop(); - *cast(bool*)arg = false; - //return false; - } - - if (event.type == SDL_KEYDOWN) { - version(WebAssembly)emscripten_cancel_main_loop(); - *cast(bool*)arg = false; - //return false; - } - } - - SDL_RenderClear(renderer); - - manager.begin(); - manager.update(); - manager.end(); - - draw(renderer,texture,vec2(32,32),vec2(32,32),vec4(0,0,1,1)); - //SDL_RenderCopy(ctx->renderer, ctx->owl_tex, NULL, &ctx->dest); - SDL_RenderPresent(renderer); - - //return true; -} - -void end() -{ - EntityManager.destroy(); - SDL_Quit(); -} \ No newline at end of file diff --git a/demos/simple/source/utils/texture.d b/demos/simple/source/utils/texture.d deleted file mode 100644 index 5b49390..0000000 --- a/demos/simple/source/utils/texture.d +++ /dev/null @@ -1,49 +0,0 @@ -module utils.texture; - -import ecs.std; - -import bindbc.sdl; -import bindbc.sdl.image; - -import ecs_utils.math.vector; - -struct Texture -{ - - void create() - { - data = Mallocator.make!Data; - } - - bool load(SDL_Renderer* renderer, const char[] path) - { - char[] cpath = (cast(char*)alloca(path.length+1))[0..path.length+1]; - //cpath[0..$-1] = path[0..$]; - memcpy(cpath.ptr, path.ptr, path.length); - cpath[$-1] = 0; - - SDL_Surface* surf = IMG_Load(cpath.ptr); - if(!surf)return false; - - data.size = ivec2(surf.w,surf.h); - - data.texture = SDL_CreateTextureFromSurface(renderer,surf); - SDL_FreeSurface(surf); - - if(!data.texture)return false; - - return true; - } - - struct Data - { - ubyte[] data; - - ivec2 size; - uint bpp; - - SDL_Texture* texture; - } - - Data* data; -} \ No newline at end of file diff --git a/demos/simple/source/utils/utils.d b/demos/simple/source/utils/utils.d deleted file mode 100644 index c7d3e9d..0000000 --- a/demos/simple/source/utils/utils.d +++ /dev/null @@ -1,110 +0,0 @@ -module utils.utils; - -extern(C) int printf(scope const char* format, ...) @nogc nothrow @system; - -version(WebAssembly) -{ - - extern (C) alias em_callback_func = void function(); - extern (C) alias em_arg_callback_func = void function(void*); - extern (C) void emscripten_set_main_loop(em_callback_func func, int fps, int simulate_infinite_loop); - extern (C) void emscripten_set_main_loop_arg(em_arg_callback_func func, void *arg, int fps, int simulate_infinite_loop); - extern (C) int emscripten_set_main_loop_timing(int mode, int value); - extern (C) void emscripten_cancel_main_loop(); - - alias int time_t; - alias int clockid_t; - enum CLOCK_REALTIME = 0; - - struct timespec - { - time_t tv_sec; - int tv_nsec; - } - - extern(C) int clock_gettime(clockid_t, timespec*) @nogc nothrow @system; - - struct Time - { - - - static long getUSecTime() - { - time_t time; - timespec spec; - - clock_gettime(CLOCK_REALTIME, &spec); - - //time = spec.tv_sec; - return spec.tv_sec * 1000_000 + spec.tv_nsec / 1000;//time / 1000_000; - - /*LARGE_INTEGER time, freq; - QueryPerformanceFrequency(&freq); - QueryPerformanceCounter(&time); - return time.QuadPart / (freq.QuadPart / 1000_000);*/ - } - } -} -else version(Windows) -{ - import core.stdc.stdio : printf; - import core.sys.windows.windows; - struct Time - { - static long getUSecTime() - { - LARGE_INTEGER time, freq; - QueryPerformanceFrequency(&freq); - QueryPerformanceCounter(&time); - return time.QuadPart / (freq.QuadPart / 1000_000); - } - } -} -else version(Posix) -{ - import core.stdc.stdio : printf; - import core.sys.posix.time; - struct Time - { - static long getUSecTime() - { - time_t time; - timespec spec; - - clock_gettime(CLOCK_REALTIME, &spec); - - //time = spec.tv_sec; - return spec.tv_sec * 1000_000 + spec.tv_nsec / 1000;//time / 1000_000; - - /*LARGE_INTEGER time, freq; - QueryPerformanceFrequency(&freq); - QueryPerformanceCounter(&time); - return time.QuadPart / (freq.QuadPart / 1000_000);*/ - } - } -} - -import bindbc.sdl; -import utils.texture; -import ecs_utils.math.vector; - -ivec2 resolution = ivec2(600, 400); - -void draw(SDL_Renderer* renderer, Texture tex, vec2 pos, vec2 size, vec4 coords, float angle = 0) -{ - - SDL_Rect rect = SDL_Rect(cast(int)(coords.x*tex.data.size.x),cast(int)(coords.y*tex.data.size.y),cast(int)(coords.z*tex.data.size.x),cast(int)(coords.w*tex.data.size.y)); - SDL_Rect rect2 = SDL_Rect(cast(int)((pos.x-size.x*0.5)), - cast(int)(resolution.y - pos.y - size.y*0.5), - cast(int)(size.x), - cast(int)(size.y)); - - SDL_RenderCopyEx(renderer, - tex.data.texture, - &rect, - &rect2, - angle*360, - null, - SDL_FLIP_NONE); - -} \ No newline at end of file diff --git a/demos/utils/dub.json b/demos/utils/dub.json index 14298cb..2f7d1bb 100644 --- a/demos/utils/dub.json +++ b/demos/utils/dub.json @@ -5,21 +5,19 @@ ], "description": "Dynamic Entity Component System examples utils", "copyright": "Copyright © 2018-2019, Michał Masiukiewicz, Dawid Masiukiewicz", - "license": "BSD", + "license": "BSD 3-clause", "sourcePaths" : [ - "source\/" + "source", + "../external/sources" ], "importPaths": [ - "source" - ], - "dflags-posix-ldc": [ - "-defaultlib=phobos2-ldc,druntime-ldc" - ], - "dflagss": [ - "-betterC" + "source", + "../external/imports", + "../external/sources" ], "dependencies": { - "bindbc-sdl":"0.10.1" + "bindbc-sdl":"0.13.0", + "ecs":{"path":"../../"} }, "versions": [ "BindSDL_Image", @@ -32,7 +30,8 @@ "targetType" : "library", "subConfigurations": { - "bindbc-sdl": "static" + "bindbc-sdl": "static", + "ecs":"library" } }, { @@ -43,7 +42,8 @@ ], "subConfigurations": { - "bindbc-sdl": "staticBC" + "bindbc-sdl": "staticBC", + "ecs":"library-betterC" } } ] diff --git a/demos/utils/source/ecs_utils/gfx/buffer.d b/demos/utils/source/ecs_utils/gfx/buffer.d new file mode 100644 index 0000000..1f38624 --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/buffer.d @@ -0,0 +1,134 @@ +module ecs_utils.gfx.buffer; + +import ecs.std; + +import glad.gl.gl; +import glad.gl.gles2; + +extern(C): + +struct Buffer +{ + + void create() nothrow + { + data = Mallocator.make!Data; + data.gl_handle = 0; + glGenBuffers(1,&data.gl_handle); + data.elem_size = 0; + } + + //--------------------------------------------------------------------------------------------------------------------------------------------------- + + void destroy() nothrow + { + if(data.gl_handle)glDeleteBuffers(1,&data.gl_handle); + } + + //--------------------------------------------------------------------------------------------------------------------------------------------------- + + void bind(BindTarget target) nothrow + { + //if(vbo != this)glBindBuffer(GL_ARRAY_BUFFER,data.gl_handle); + //vbo = this; + glBindBuffer(target,data.gl_handle); + } + + void bindRange(BindTarget target, uint index, uint offset, uint size) nothrow + { + glBindBufferRange(target, index, data.gl_handle, offset, size); + } + + //--------------------------------------------------------------------------------------------------------------------------------------------------- + + void bufferData(BindTarget target, uint size, uint count, uint usage, void* data) nothrow + { + bind(target); + this.data.elem_size = size; + glBufferData(target,size*count,data,usage); + } + + /*void bufferStorage(uint size, uint count, void* data, uint flags = StorageFlagBits.write) + { + bind(BindTarget.array); + this.data.elem_size = size; + glBufferStorage(GL_ARRAY_BUFFER,size*count,data, flags); + }*/ + + void bufferSubData(uint size, uint offset, void* data) nothrow + { + bind(BindTarget.array); + glBufferSubData(GL_ARRAY_BUFFER,offset,size,data); + } + + void map(BindTarget target) nothrow + { + bind(target); + data.map_ptr = glMapBuffer(target,GL_WRITE_ONLY); + } + + void map(uint offset, uint size, BindTarget target, uint flags = MapFlagBits.write | MapFlagBits.flush_explict | MapFlagBits.invalidate_buffer) nothrow + { + bind(target); + data.map_ptr = glMapBufferRange(target,offset,size,flags); + } + + void flush(uint offset, uint size, BindTarget target) nothrow + { + glFlushMappedBufferRange(target, offset, size); + } + + void unmap(BindTarget target) nothrow + { + bind(target); + glUnmapBuffer(target); + data.map_ptr = null; + } + + void* mappedPointer() nothrow + { + return data.map_ptr; + } + + //--------------------------------------------------------------------------------------------------------------------------------------------------- + + static void unbind(BindTarget target) nothrow + { + //vbo = 0; + glBindBuffer(target,0); + } + + enum BindTarget + { + array = GL_ARRAY_BUFFER, + element_array = GL_ELEMENT_ARRAY_BUFFER, + uniform = GL_UNIFORM_BUFFER, + //shader_storage = GL_SHADER_STORAGE_BUFFER, + //indirect = GL_DRAW_INDIRECT_BUFFER + } + + enum MapFlagBits + { + write = GL_MAP_WRITE_BIT, + invalidate_buffer = GL_MAP_INVALIDATE_BUFFER_BIT, + flush_explict = GL_MAP_FLUSH_EXPLICIT_BIT, + //coherent = GL_MAP_COHERENT_BIT, + //persistent = GL_MAP_PERSISTENT_BIT + } + + enum StorageFlagBits + { + write = GL_MAP_WRITE_BIT, + //coherent = GL_MAP_COHERENT_BIT, + //persistent = GL_MAP_PERSISTENT_BIT + } + + struct Data + { + uint elem_size; + uint gl_handle; + void* map_ptr; + } + + Data* data; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/config.d b/demos/utils/source/ecs_utils/gfx/config.d new file mode 100644 index 0000000..de5528a --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/config.d @@ -0,0 +1,102 @@ +module ecs_utils.gfx.config; + +import bindbc.sdl; + +import ecs.std; + +import ecs_utils.gfx.material; +import ecs_utils.gfx.mesh; +import ecs_utils.gfx.texture; + +//import mutils.serializer.json; + +extern(C): + +enum LayerType +{ + normal, + sorted +} + +import ecs.vector; + +static struct GfxConfig +{ + extern(C): + __gshared: + Vector!LayerType layers; + //Vector!Mesh meshes; + //Vector!Material materials; + Mesh[] meshes; + Material[] materials; + + static bool load(const (char)[] path) nothrow + { + struct LoadData + { + struct Str + { + @("malloc") string str; + } + + @("malloc") Str[] materials; + @("malloc") Str[] meshes; + int inter; + + void dispose() nothrow + { + /*if(blend_mode)Mallocator.instance.dispose(cast(char[])blend_mode); + if(vertex)Mallocator.instance.dispose(cast(char[])vertex); + if(fragment)Mallocator.instance.dispose(cast(char[])fragment);*/ + } + } + + char[] cpath = (cast(char*)alloca(path.length+1))[0..path.length+1]; + cpath[0..$-1] = path[0..$]; + cpath[$-1] = 0; + + SDL_RWops* file = SDL_RWFromFile(cpath.ptr,"r"); + if(file) + { + size_t size = cast(size_t)SDL_RWsize(file); + char[] buffer = Mallocator.makeArray!char(size); + SDL_RWread(file,buffer.ptr,size,1); + + LoadData load_data; + scope(exit)load_data.dispose(); + + /*JSONSerializer serializer = Mallocator.make!JSONSerializer; + scope(exit)Mallocator.dispose(serializer); + serializer.serialize!(Load.yes, true)(load_data,buffer);*/ + + //if(__ecs_used_backend == Backend.opengl) + { + meshes = Mallocator.makeArray!Mesh(load_data.meshes.length); + foreach(i,ref mesh; meshes) + { + mesh.load(load_data.meshes[i].str); + mesh.uploadData(); + } + } + + materials = Mallocator.makeArray!Material(load_data.materials.length); + foreach(i,ref material; materials) + { + material.create(); + material.load(load_data.materials[i].str); + material.compile(); + } + + SDL_RWclose(file); + load_data.dispose(); + return true; + } + else return false; + } + + static int addLayer(LayerType type) + { + layers.add(type); + return cast(int)(layers.length-1); + } +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/material.d b/demos/utils/source/ecs_utils/gfx/material.d new file mode 100644 index 0000000..b697992 --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/material.d @@ -0,0 +1,198 @@ +module ecs_utils.gfx.material; + +import bindbc.sdl; + +import ecs.std; + +import ecs_utils.gfx.shader; + +import glad.gl.gl; + +//import mutils.serializer.json; + +struct Material +{ + + void create() nothrow + { + data = Mallocator.make!Data; + } + + bool load(const char[] path) nothrow + { + struct LoadData + { + @("malloc") string blend_mode; + @("malloc") string vertex; + @("malloc") string fragment; + + void dispose() nothrow + { + //if(blend_mode)Mallocator.instance.dispose(cast(char[])blend_mode); + //if(vertex)Mallocator.instance.dispose(cast(char[])vertex); + //if(fragment)Mallocator.instance.dispose(cast(char[])fragment); + } + } + + char[] cpath = (cast(char*)alloca(path.length+1))[0..path.length+1]; + cpath[0..$-1] = path[0..$]; + cpath[$-1] = 0; + + SDL_RWops* file = SDL_RWFromFile(cpath.ptr,"r"); + if(file) + { + size_t size = cast(size_t)SDL_RWsize(file); + char[] buffer = Mallocator.makeArray!char(size); + SDL_RWread(file,buffer.ptr,size,1); + + LoadData load_data; + scope(exit)load_data.dispose(); + + /*JSONSerializer serializer = Mallocator.make!JSONSerializer; + scope(exit)Mallocator.dispose(serializer); + serializer.serialize!(Load.yes, true)(load_data,buffer);*/ + + //if(__ecs_used_backend == Backend.opengl) + { + Shader vsh; + vsh.load(load_data.vertex); + vsh.compile(); + + Shader fsh; + fsh.load(load_data.fragment); + fsh.compile(); + + Material.ShaderModule[1] modules = [Material.ShaderModule(vsh,fsh)]; + + attachModules(modules); + } + + SDL_RWclose(file); + load_data.dispose(); + return true; + } + else return false; + } + + void bind() nothrow + { + glUseProgram(data.modules[0].gl_handle); + } + + enum BlendMode + { + opaque, + additive, + mixed + } + + enum TransformMode + { + position, + matrix + } + + struct ShaderModule + { + Shader fragment_shader; + Shader vertex_shader; + uint gl_handle; + } + + void attachModules(scope ShaderModule[] modules) nothrow + { + data.modules = Mallocator.makeArray(modules); + } + + bool compile() nothrow + { + foreach(ref module_;data.modules) + { + module_.gl_handle = glCreateProgram(); + glAttachShader(module_.gl_handle, module_.vertex_shader.data.gl_handle); + glAttachShader(module_.gl_handle, module_.fragment_shader.data.gl_handle); + } + + return true; + } + + void bindAttribLocation(const char* name, uint location) nothrow + { + foreach(ref module_;data.modules) + { + glBindAttribLocation(module_.gl_handle, location, name); + } + } + + bool link() nothrow + { + foreach(ref module_;data.modules) + { + glLinkProgram(module_.gl_handle); + + GLint ok = 0; + glGetProgramiv(module_.gl_handle, GL_LINK_STATUS, &ok); + if(!ok) + { + SDL_Log("Program link error!"); + return false; + } + } + + return true; + } + + int getLocation(const char* name) + { + foreach(ref module_;data.modules) + { + int location = glGetUniformLocation(module_.gl_handle,name); + if(location != -1)return location; + } + return -1; + } + + void pushBindings() + { + foreach(i;0..data.bindings.length) + { + glUniform1i(data.bindings[i],cast(int)i); + } + } + + void pushUniforms(void* ptr) + { + foreach(ref Uniform uniform; data.uniforms) + { + void* local_ptr = ptr + uniform.offset; + glUniform4fv(uniform.location,1,cast(float*)local_ptr); + } + } + + enum Type + { + float_, + float4 + } + + struct Uniform + { + Type type; + int location; + uint offset; + } + + struct Data + { + BlendMode blend_mode = BlendMode.opaque; + + ShaderModule[] modules; + + TransformMode mode; + + Uniform[] uniforms; + int[] bindings; + } + + Data* data; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/mesh.d b/demos/utils/source/ecs_utils/gfx/mesh.d new file mode 100644 index 0000000..346226f --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/mesh.d @@ -0,0 +1,121 @@ +module ecs_utils.gfx.mesh; + +import bindbc.sdl; + +import ecs.std; + +import ecs_utils.gfx.buffer; + +import glad.gl.gl; +//import mutils.serializer.json; + +extern(C): + +struct Mesh +{ + bool load(const char[] path) nothrow + { + struct LoadData + { + /*struct Vertex + { + struct Binding + { + @("malloc") string type; + uint stride; + } + @("malloc") Binding[] bindings; + } + Vertex vertex;*/ + @("malloc") ushort[] indices; + @("malloc") float[] vertices; + //int i; + + void dispose() nothrow + { + if(indices)Mallocator.dispose(indices); + if(vertices)Mallocator.dispose(vertices); + + /*foreach(binding; vertex.bindings)Mallocator.instance.dispose(cast(char[])binding.type); + + if(vertex.bindings)Mallocator.instance.dispose(vertex.bindings);*/ + } + } + + char[] cpath = (cast(char*)alloca(path.length+1))[0..path.length+1]; + cpath[0..$-1] = path[0..$]; + cpath[$-1] = 0; + + SDL_RWops* file = SDL_RWFromFile(cpath.ptr,"r");//SDL_LoadFile(cpath.ptr,); + if(file) + { + size_t size = cast(size_t)SDL_RWsize(file); + //data.code = Mallocator.instance.makeArray!char(size); + //data.code[$-1] = 0; + char[] buffer = Mallocator.makeArray!char(size); + SDL_RWread(file,buffer.ptr,size,1); + + LoadData load_data; + scope(exit)load_data.dispose(); + + /*JSONSerializer serializer = Mallocator.make!JSONSerializer; + scope(exit)Mallocator.dispose(serializer); + serializer.serialize!(Load.yes, true)(load_data,buffer);*/ + + indices = Mallocator.makeArray(load_data.indices); + /*vertex.create(); + Vertex.Binding[] bindings = (cast(Vertex.Binding*)alloca(Vertex.Binding.sizeof*load_data.vertex.bindings.length))[0..load_data.vertex.bindings.length]; + uint vertex_size = 0; + uint alignment = 4; + foreach(i, binding;load_data.vertex.bindings) + { + uint new_size = binding.stride; + bindings[i].stride = binding.stride; + if(binding.type == "float_rg") + { + bindings[i].type = Vertex.Type.float_rg; + new_size += 8; + } + if(new_size > vertex_size)vertex_size = new_size; + //new_size = new_size + (3 - (new_size)%alignment) + } + vertex.data.size = vertex_size; + vertex.attachBindings(bindings);*/ + + vertices = Mallocator.makeArray(load_data.vertices); + /*vertices = Mallocator.instance.makeArray!ubyte(vertex_size * load_data.vertices.length); + { + foreach() + }*/ + + SDL_RWclose(file); + load_data.dispose(); + return true; + } + else return false; + } + + void uploadData() nothrow + { + vbo.create(); + vbo.bufferData(Buffer.BindTarget.array,16,cast(uint)vertices.length,GL_STATIC_DRAW,vertices.ptr); + + ibo.create(); + ibo.bufferData(Buffer.BindTarget.element_array,2,cast(uint)indices.length,GL_STATIC_DRAW,indices.ptr); + } + + void bind() nothrow + { + vbo.bind(Buffer.BindTarget.array); + ibo.bind(Buffer.BindTarget.element_array); + + glVertexAttribPointer(0,2,GL_FLOAT,false,16,null); + glVertexAttribPointer(1,2,GL_FLOAT,false,16,cast(void*)8); + } + + float[] vertices; + ushort[] indices; + Buffer vbo; + Buffer ibo; + //Vertex vertex; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/mesh_module.d b/demos/utils/source/ecs_utils/gfx/mesh_module.d new file mode 100644 index 0000000..ecb4a3a --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/mesh_module.d @@ -0,0 +1,12 @@ +module ecs_utils.gfx.mesh_module; + +import ecs_utils.gfx.material; +import ecs_utils.gfx.texture; +import ecs_utils.gfx.mesh; + +struct MeshModule +{ + Mesh* mesh; + Material* material; + Texture texture; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/render_list.d b/demos/utils/source/ecs_utils/gfx/render_list.d new file mode 100644 index 0000000..f5ffabf --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/render_list.d @@ -0,0 +1,29 @@ +module ecs_utils.gfx.render_list; + +import ecs_utils.gfx.mesh_module; +import ecs_utils.math.vector; +import ecs_utils.math.matrix; +import ecs_utils.gfx.config; + +struct RenderList +{ + struct Data + { + MeshModule* module_; + uint index; + } + + struct LocScale + { + vec2 location; + vec2 scale; + } + + struct Layer + { + LayerType type; + Data[] list; + LocScale[] loc_scale; + mat3[] matrices; + } +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/renderer.d b/demos/utils/source/ecs_utils/gfx/renderer.d new file mode 100644 index 0000000..5b151bc --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/renderer.d @@ -0,0 +1,817 @@ +module ecs_utils.gfx.renderer; + +import bindbc.sdl; + +import ecs.std; + +//import ecs_utils.core : Backend; +import ecs_utils.gfx.buffer; +import ecs_utils.gfx.texture; +import ecs_utils.math.vector; + +import glad.gl.gl; + +version = ver1; +/*version(ver5)version = vv2; +else version(ver6)version = vv2;*/ + +extern(C) float sinf(float); +extern(C) float cosf(float); + +enum RenderTechnique +{ + simple,//1 + simple_array,//2 + vbo_batch,//3 + instanced_attrib_divisor,//4 + uniform_buffer,//5 + uniform_buffer_indexed,//6 + uniform_buffer_multi_draw,//7 + uniform_buffer_instanced,//8 + uniform_buffer_instanced_mapped_gl2,//9 + uniform_buffer_instanced_mapped,//10 + uniform_buffer_instanced_persistent_mapped,//11 + uniform_buffer_instanced_persistent_mapped_coherent,//12 + ssbo_instanced,//13 + uniform_buffer_draw_indirect,//14 + uniform_buffer_multi_draw_indirect,//15 + uniform_buffer_multi_draw_indirect_arb_draw_parameters//16 +} + +struct Renderer +{ + //static SDL_Renderer* main_sdl_renderer; + + enum MaxObjects = 1024 * 64 * 4; + enum BufferUsage = GL_STATIC_DRAW; + + //SDL_Window* sdl_window; + //SDL_Renderer* sdl_renderer; + ivec2 resolution; + vec2 dres; + vec4 sdl_transform; + vec2 view_pos = vec2(-1,-1); + vec2 view_size = vec2(1,1); + + //uint[2] time_queries; + + Buffer[2] ubos; + int block_alignment = 1; + int block_max_size = 16384; + + struct IndirectDraw + { + uint count = 6; + uint instances = 1; + uint first_index = 0; + uint base_vertex = 0; + uint base_instance = 0; + } + + Buffer[2] batch_vbo; + Buffer[2] batch_ibo; + + float[] batch_vertices; + ushort[] batch_indices; + + Buffer indirect_buffer; + IndirectDraw[] indirect_block; + + Buffer id_buffer; + + int data_offset = 48; + int data_index; + ubyte[] uniform_block; + + struct RenderData + { + Texture texture; + uint material_id; + uint mesh_id; + } + + RenderData[] render_list; + uint item_id; + + uint[] multi_count; + uint[] multi_offset; + + alias Technique = RenderTechnique; + + __gshared Technique technique = Technique.simple; + void* data_ptr; + + //import ecs_utils.core : RenderTechnique; + + + + void initialize() + { + //this.technique = __ecs_used_technique; + __initialize(this); + } + + private static void __initialize_gl(ref Renderer this_) + { + with(this_) + { + //glGenQueries(2, time_queries.ptr); + + version(WebAssembly) + { + + } + else + { + glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &block_max_size); + glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &block_alignment); + } + + //ubos[0].bufferStorage(1,64*MaxObjects,null); + + switch(technique) + { + case Technique.simple: + uniform_block = Mallocator.makeArray!ubyte(64*MaxObjects); + data_ptr = uniform_block.ptr; + data_offset = cast(ushort)((data_offset + block_alignment - 1) & (-cast(int) block_alignment)); + break; + case Technique.simple_array: + goto case(Technique.simple); + case Technique.vbo_batch: + batch_vbo[0].create(); + batch_ibo[0].create(); + batch_vbo[0].bufferData(Buffer.BindTarget.array,16,4*MaxObjects,BufferUsage,null); + batch_ibo[0].bufferData(Buffer.BindTarget.element_array,2,6*MaxObjects,BufferUsage,null); + + batch_vbo[1].create(); + batch_ibo[1].create(); + batch_vbo[1].bufferData(Buffer.BindTarget.array,16,4*MaxObjects,BufferUsage,null); + batch_ibo[1].bufferData(Buffer.BindTarget.element_array,2,6*MaxObjects,BufferUsage,null); + + batch_vertices = Mallocator.makeArray!float(16*MaxObjects); + batch_indices = Mallocator.makeArray!ushort(6*MaxObjects); + break; + case Technique.instanced_attrib_divisor: + goto case(Technique.uniform_buffer_indexed); + case Technique.uniform_buffer: + ubos[0].create(); + ubos[0].bufferData(Buffer.BindTarget.uniform,1,64*MaxObjects,BufferUsage,null); + ubos[1].create(); + ubos[1].bufferData(Buffer.BindTarget.uniform,1,64*MaxObjects,BufferUsage,null); + goto case(Technique.simple); + case Technique.uniform_buffer_indexed: + ubos[0].create(); + ubos[0].bufferData(Buffer.BindTarget.uniform,1,64*MaxObjects,BufferUsage,null); + ubos[1].create(); + ubos[1].bufferData(Buffer.BindTarget.uniform,1,64*MaxObjects,BufferUsage,null); + uniform_block = Mallocator.makeArray!ubyte(64*MaxObjects); + data_ptr = uniform_block.ptr; + break; + /*case Technique.uniform_buffer_multi_draw: + multi_count = Mallocator.makeArray!uint(992,6); + multi_offset = Mallocator.makeArray!uint(992,0); + + { + uint[] indices = Mallocator.makeArray!uint(992); + scope(exit)Mallocator.dispose(indices); + foreach(i;0..992)indices[i]=i; + id_buffer.create(); + id_buffer.bufferData(uint.sizeof,992,BufferUsage,indices.ptr); + } + goto case(Technique.uniform_buffer_multi_draw_indirect_arb_draw_parameters);*/ + case Technique.uniform_buffer_instanced: + goto case(Technique.uniform_buffer_indexed); + case Technique.uniform_buffer_instanced_mapped_gl2: + ubos[0].create(); + ubos[0].bufferData(Buffer.BindTarget.uniform,1,512*MaxObjects,BufferUsage,null); + ubos[0].map(Buffer.BindTarget.uniform); + ubos[1].create(); + ubos[1].bufferData(Buffer.BindTarget.uniform,1,512*MaxObjects,BufferUsage,null); + ubos[1].map(Buffer.BindTarget.uniform); + data_ptr = ubos[0].mappedPointer(); + break; + case Technique.uniform_buffer_instanced_mapped: + ubos[0].create(); + ubos[0].bufferData(Buffer.BindTarget.uniform,1,64*MaxObjects,BufferUsage,null); + ubos[0].map(0, 64*MaxObjects, Buffer.BindTarget.uniform); + ubos[1].create(); + ubos[1].bufferData(Buffer.BindTarget.uniform,1,64*MaxObjects,BufferUsage,null); + ubos[1].map(0, 64*MaxObjects, Buffer.BindTarget.uniform); + data_ptr = ubos[0].mappedPointer(); + break; + /*case Technique.uniform_buffer_instanced_persistent_mapped: + ubos[0].create(); + ubos[0].bufferStorage(1,64*MaxObjects,null,Buffer.StorageFlagBits.write|Buffer.StorageFlagBits.persistent); + ubos[0].map(0, 64*MaxObjects, Buffer.BindTarget.uniform, Buffer.MapFlagBits.write | Buffer.MapFlagBits.persistent | Buffer.MapFlagBits.flush_explict); + data_ptr = ubos[0].mappedPointer(); + break; + case Technique.uniform_buffer_instanced_persistent_mapped_coherent: + ubos[0].create(); + ubos[0].bufferStorage(1,64*MaxObjects,null,Buffer.StorageFlagBits.write|Buffer.StorageFlagBits.persistent|Buffer.StorageFlagBits.coherent); + ubos[0].map(0, 64*MaxObjects, Buffer.BindTarget.uniform, Buffer.MapFlagBits.write | Buffer.MapFlagBits.persistent | Buffer.MapFlagBits.flush_explict | Buffer.MapFlagBits.coherent); + ubos[1].create(); + ubos[1].bufferStorage(1,64*MaxObjects,null,Buffer.StorageFlagBits.write|Buffer.StorageFlagBits.persistent|Buffer.StorageFlagBits.coherent); + ubos[1].map(0, 64*MaxObjects, Buffer.BindTarget.uniform, Buffer.MapFlagBits.write | Buffer.MapFlagBits.persistent | Buffer.MapFlagBits.flush_explict | Buffer.MapFlagBits.coherent); + data_ptr = ubos[0].mappedPointer(); + break; + case Technique.ssbo_instanced: + goto case(Technique.uniform_buffer_indexed); + case Technique.uniform_buffer_draw_indirect: + indirect_block = Mallocator.makeArray!IndirectDraw(1); + indirect_buffer.create(); + indirect_buffer.bufferData(IndirectDraw.sizeof,1,BufferUsage,indirect_block.ptr); + indirect_buffer.bind(Buffer.BindTarget.indirect); + goto case(Technique.uniform_buffer); + case Technique.uniform_buffer_multi_draw_indirect: + goto case(Technique.uniform_buffer_multi_draw_indirect_arb_draw_parameters); + case Technique.uniform_buffer_multi_draw_indirect_arb_draw_parameters: + indirect_block = Mallocator.makeArray!IndirectDraw(992); + foreach(i;0..992) + { + IndirectDraw* idraw = &indirect_block[i]; + idraw.base_instance = i; + } + indirect_buffer.create(); + indirect_buffer.bufferData(IndirectDraw.sizeof,992,BufferUsage,indirect_block.ptr); + indirect_buffer.bind(Buffer.BindTarget.indirect); + goto case(Technique.uniform_buffer_indexed);*/ + default:break; + }//*/ + + // if(batching)data_offset = cast(ushort)((data_offset + block_alignment - 1) & (-cast(int) block_alignment)); + //data_offset = cast(ushort)((data_offset + block_alignment - 1) & (-cast(int) block_alignment)); + + /*version(ver4){} + else version(ver5){} + else version(ver6){} + else data_offset = cast(ushort)((data_offset + block_alignment - 1) & (-cast(int) block_alignment));//*/ + //data_offset = (data_offset + block_alignment - 1) - data_offset % block_alignment; + + render_list = Mallocator.makeArray!RenderData(MaxObjects); + + SDL_Log("Uniform block alignment: %u",block_alignment); + SDL_Log("Uniform block max size: %u",block_max_size); + SDL_Log("Data offset: %u",data_offset); + } + } + + private static void __initialize_sdl(ref Renderer this_) + { + + } + + void draw(Texture tex, vec2 pos, vec2 size, vec4 coords, float angle = 0, uint material_id = 0, uint mesh_id = 0) + { + __draw(this,tex,pos,size,coords,angle,material_id,mesh_id); + } + + private static void __draw_sdl(ref Renderer this_, Texture tex, vec2 pos, vec2 size, vec4 coords, float angle, uint material_id, uint mesh_id) + { + /*with(this_) + { + SDL_Rect rect = SDL_Rect(cast(int)(coords.x*tex.data.size.x),cast(int)(coords.y*tex.data.size.y),cast(int)(coords.z*tex.data.size.x),cast(int)(coords.w*tex.data.size.y)); + SDL_Rect rect2 = SDL_Rect(cast(int)((pos.x-size.x*0.5)), + cast(int)(resolution.y - pos.y - size.y*0.5), + cast(int)(size.x), + cast(int)(size.y)); + + SDL_RenderCopyEx(sdl_renderer, + tex.data.texture, + &rect, + &rect2, + angle*360, + null, + SDL_FLIP_NONE); + }*/ + } + + private static void __draw_gl(ref Renderer this_, Texture tex, vec2 pos, vec2 size, vec4 coords, float angle, uint material_id, uint mesh_id) + { + //import core.stdc.string; + with(this_) + { + //pos += view_pos; + size.x *= view_size.x; + size.y *= view_size.y; + pos.x = pos.x * view_size.x + view_pos.x; + pos.y = pos.y * view_size.y + view_pos.y;//*/ + + /*version(ver6)void* ptr = ubos[0].mappedPointer() + data_index; + else void* ptr = uniform_block.ptr + data_index;*/ + if(data_ptr is null)return; + void* ptr = data_ptr + data_index; + if(angle == 0) + { + *cast(float*)ptr = size.x; + *cast(float*)(ptr+4) = 0; + *cast(float*)(ptr+8) = 0; + *cast(float*)(ptr+12) = size.y; + } + else + { + //import core.stdc.math; + float sinn = sinf(angle); + float coss = cosf(angle); + *cast(float*)ptr = coss * size.x; + *cast(float*)(ptr+4) = -sinn * size.y; + *cast(float*)(ptr+8) = sinn * size.x; + *cast(float*)(ptr+12) = coss * size.y; + } + + //memcpy(ptr,); + memcpy(ptr+16,pos.data.ptr,8); + memcpy(ptr+32,coords.data.ptr,16); + + //render_list[item_id] = RenderData(tex,material_id,mesh_id); + render_list[item_id].texture = tex; + render_list[item_id].material_id = material_id; + render_list[item_id].mesh_id = mesh_id; + + data_index += data_offset; + item_id++; + } + } + + private static void __draw_gl_vbo_batch(ref Renderer this_, Texture tex, vec2 pos, vec2 size, vec4 coords, float angle, uint material_id, uint mesh_id) + { + import ecs_utils.gfx.config; + //import core.stdc.string; + with(this_) + { + //pos += view_pos; + size.x *= view_size.x; + size.y *= view_size.y; + pos.x = pos.x * view_size.x + view_pos.x; + pos.y = pos.y * view_size.y + view_pos.y;//*/ + + /*void* ptr = data_ptr + data_index; + *cast(float*)ptr = size.x; + *cast(float*)(ptr+4) = 0; + *cast(float*)(ptr+8) = 0; + *cast(float*)(ptr+12) = size.y; + //memcpy(ptr,); + memcpy(ptr+16,pos.data.ptr,8); + memcpy(ptr+32,coords.data.ptr,16);*/ + + if(angle == 0) + { + batch_vertices[item_id*16] = GfxConfig.meshes[mesh_id].vertices[0] * size.x + pos.x; + batch_vertices[item_id*16+1] = GfxConfig.meshes[mesh_id].vertices[1] * size.y + pos.y; + batch_vertices[item_id*16+4] = GfxConfig.meshes[mesh_id].vertices[4] * size.x + pos.x; + batch_vertices[item_id*16+5] = GfxConfig.meshes[mesh_id].vertices[5] * size.y + pos.y; + batch_vertices[item_id*16+8] = GfxConfig.meshes[mesh_id].vertices[8] * size.x + pos.x; + batch_vertices[item_id*16+9] = GfxConfig.meshes[mesh_id].vertices[9] * size.y + pos.y; + batch_vertices[item_id*16+12] = GfxConfig.meshes[mesh_id].vertices[12] * size.x + pos.x; + batch_vertices[item_id*16+13] = GfxConfig.meshes[mesh_id].vertices[13] * size.y + pos.y; + } + else + { + //import core.stdc.math; + float sinn = sinf(angle); + float coss = cosf(angle); + + /*batch_vertices[item_id*16] = GfxConfig.meshes[mesh_id].vertices[0] * size.x; + batch_vertices[item_id*16+1] = GfxConfig.meshes[mesh_id].vertices[1] * size.y; + batch_vertices[item_id*16+4] = GfxConfig.meshes[mesh_id].vertices[4] * size.x; + batch_vertices[item_id*16+5] = GfxConfig.meshes[mesh_id].vertices[5] * size.y; + batch_vertices[item_id*16+8] = GfxConfig.meshes[mesh_id].vertices[8] * size.x; + batch_vertices[item_id*16+9] = GfxConfig.meshes[mesh_id].vertices[9] * size.y; + batch_vertices[item_id*16+12] = GfxConfig.meshes[mesh_id].vertices[12] * size.x; + batch_vertices[item_id*16+13] = GfxConfig.meshes[mesh_id].vertices[13] * size.y;*/ + + batch_vertices[item_id*16] = (GfxConfig.meshes[mesh_id].vertices[0] * coss + GfxConfig.meshes[mesh_id].vertices[1] * sinn) * size.x + pos.x; + batch_vertices[item_id*16+1] = (GfxConfig.meshes[mesh_id].vertices[1] * coss - GfxConfig.meshes[mesh_id].vertices[0] * sinn) * size.y + pos.y; + batch_vertices[item_id*16+4] = (GfxConfig.meshes[mesh_id].vertices[4] * coss + GfxConfig.meshes[mesh_id].vertices[5] * sinn) * size.x + pos.x; + batch_vertices[item_id*16+5] = (GfxConfig.meshes[mesh_id].vertices[5] * coss - GfxConfig.meshes[mesh_id].vertices[4] * sinn) * size.y + pos.y; + batch_vertices[item_id*16+8] = (GfxConfig.meshes[mesh_id].vertices[8] * coss + GfxConfig.meshes[mesh_id].vertices[9] * sinn) * size.x + pos.x; + batch_vertices[item_id*16+9] = (GfxConfig.meshes[mesh_id].vertices[9] * coss - GfxConfig.meshes[mesh_id].vertices[8] * sinn) * size.y + pos.y; + batch_vertices[item_id*16+12] = (GfxConfig.meshes[mesh_id].vertices[12] * coss + GfxConfig.meshes[mesh_id].vertices[13] * sinn) * size.x + pos.x; + batch_vertices[item_id*16+13] = (GfxConfig.meshes[mesh_id].vertices[13] * coss - GfxConfig.meshes[mesh_id].vertices[12] * sinn) * size.y + pos.y; + } + + batch_vertices[item_id*16+2] = GfxConfig.meshes[mesh_id].vertices[2] * coords.z + coords.x; + batch_vertices[item_id*16+3] = GfxConfig.meshes[mesh_id].vertices[3] * coords.w + coords.y; + batch_vertices[item_id*16+6] = GfxConfig.meshes[mesh_id].vertices[6] * coords.z + coords.x; + batch_vertices[item_id*16+7] = GfxConfig.meshes[mesh_id].vertices[7] * coords.w + coords.y; + batch_vertices[item_id*16+10] = GfxConfig.meshes[mesh_id].vertices[10] * coords.z + coords.x; + batch_vertices[item_id*16+11] = GfxConfig.meshes[mesh_id].vertices[11] * coords.w + coords.y; + batch_vertices[item_id*16+14] = GfxConfig.meshes[mesh_id].vertices[14] * coords.z + coords.x; + batch_vertices[item_id*16+15] = GfxConfig.meshes[mesh_id].vertices[15] * coords.w + coords.y; + + uint ind_id = item_id % 16_384; + + batch_indices[item_id*6] = cast(ushort)(GfxConfig.meshes[mesh_id].indices[0] + ind_id*4); + batch_indices[item_id*6+1] = cast(ushort)(GfxConfig.meshes[mesh_id].indices[1] + ind_id*4); + batch_indices[item_id*6+2] = cast(ushort)(GfxConfig.meshes[mesh_id].indices[2] + ind_id*4); + batch_indices[item_id*6+3] = cast(ushort)(GfxConfig.meshes[mesh_id].indices[3] + ind_id*4); + batch_indices[item_id*6+4] = cast(ushort)(GfxConfig.meshes[mesh_id].indices[4] + ind_id*4); + batch_indices[item_id*6+5] = cast(ushort)(GfxConfig.meshes[mesh_id].indices[5] + ind_id*4); + + //render_list[item_id] = RenderData(tex,material_id,mesh_id); + render_list[item_id].texture = tex; + render_list[item_id].material_id = material_id; + render_list[item_id].mesh_id = mesh_id; + + //data_index += 1;//data_offset; + item_id++; + } + } + + void clear() + { + __clear(this); + } + + private static void __clear_sdl(ref Renderer this_) + { + //SDL_RenderClear(this_.sdl_renderer); + } + + private static void __clear_gl(ref Renderer this_) + { + glClearColor(0,0,0,0); + glViewport(0,0,this_.resolution.x,this_.resolution.y); + glClear(GL_COLOR_BUFFER_BIT);// | GL_DEPTH_BUFFER_BIT); + glDisable(GL_DEPTH_TEST); + glDisable(GL_CULL_FACE); + } + + void present() + { + __present(this); + } + + private static void __present_sdl(ref Renderer this_) + { + //+SDL_RenderPresent(this_.sdl_renderer); + } + + private static void __present_gl(ref Renderer this_) + { + glViewport(0,0,this_.resolution.x,this_.resolution.y); + //glEnable(GL_ALPHA_TEST); + //glAlphaFunc(GL_GREATER, 0.01); + glEnableVertexAttribArray(0); + glEnableVertexAttribArray(1); + import ecs_utils.gfx.config; + with(this_) + { + bool instanced = false; + bool indirect = false; + bool multi_draw = false; + Buffer.BindTarget buffer_target = Buffer.BindTarget.uniform; + + switch(technique) + { + case Technique.simple: + break; + case Technique.simple_array: + break; + case Technique.vbo_batch: + //if(data_index){ + batch_vbo[0].bufferSubData(item_id*4*16,0,batch_vertices.ptr); + batch_ibo[0].bufferSubData(item_id*6*2,0,batch_indices.ptr); + + batch_vbo[0].bind(Buffer.BindTarget.array); + batch_ibo[0].bind(Buffer.BindTarget.element_array); + + glVertexAttribPointer(0,2,GL_FLOAT,false,16,null); + glVertexAttribPointer(1,2,GL_FLOAT,false,16,cast(void*)8);//} + break; + case Technique.instanced_attrib_divisor: + ubos[0].bufferSubData(data_index,0,uniform_block.ptr); + ubos[0].bind(Buffer.BindTarget.array); + glEnableVertexAttribArray(2); + glEnableVertexAttribArray(3); + glEnableVertexAttribArray(4); + + glVertexAttribPointer(2,4,GL_FLOAT,false,48,null); + glVertexAttribPointer(3,4,GL_FLOAT,false,48,cast(void*)16); + glVertexAttribPointer(4,4,GL_FLOAT,false,48,cast(void*)32); + glVertexAttribDivisor(2,1); + glVertexAttribDivisor(3,1); + glVertexAttribDivisor(4,1); + //ubos[0].bindRange(Buffer.BindTarget.uniform,0,0,block_max_size); + break; + case Technique.uniform_buffer: + //ubos[0].bufferData(1,64*MaxObjects,BufferUsage,null); + /*if(data_index)*/ubos[0].bufferSubData(data_index,0,uniform_block.ptr); + break; + case Technique.uniform_buffer_indexed: + ubos[0].bindRange(Buffer.BindTarget.uniform,0,0,block_max_size); + goto case(Technique.uniform_buffer); + case Technique.uniform_buffer_multi_draw: + id_buffer.bind(Buffer.BindTarget.array); + glEnableVertexAttribArray(2); + + glVertexAttribIPointer(2,1,GL_UNSIGNED_INT,cast(uint)uint.sizeof,cast(void*)0); + glVertexAttribDivisor(2,1); + multi_draw = true; + goto case(Technique.uniform_buffer_instanced); + case Technique.uniform_buffer_instanced: + instanced = true; + goto case(Technique.uniform_buffer); + case Technique.uniform_buffer_instanced_mapped_gl2: + instanced = true; + ubos[0].unmap(Buffer.BindTarget.uniform); + break; + case Technique.uniform_buffer_instanced_mapped: + instanced = true; + ubos[0].flush(0,data_index,Buffer.BindTarget.uniform); + ubos[0].unmap(Buffer.BindTarget.uniform); + break; + /*case Technique.uniform_buffer_instanced_persistent_mapped: + instanced = true; + ubos[0].flush(0,data_index,Buffer.BindTarget.uniform); + //glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT); + break; + case Technique.uniform_buffer_instanced_persistent_mapped_coherent: + instanced = true; + break; + //ubos[0].flush(0,data_index,Buffer.BindTarget.uniform); + //goto case(Technique.uniform_buffer_instanced_mapped); + case Technique.ssbo_instanced: + //buffer_target = Buffer.BindTarget.shader_storage; + ubos[0].bindRange(Buffer.BindTarget.shader_storage,0,0,48*MaxObjects); + goto case(Technique.uniform_buffer_instanced); + case Technique.uniform_buffer_draw_indirect: + goto case(Technique.uniform_buffer); + case Technique.uniform_buffer_multi_draw_indirect: + indirect_buffer.bind(Buffer.BindTarget.array); + glEnableVertexAttribArray(2); + + glVertexAttribIPointer(2,1,GL_UNSIGNED_INT,cast(uint)IndirectDraw.sizeof,cast(void*)(4*uint.sizeof)); + glVertexAttribDivisor(2,1); + goto case(Technique.uniform_buffer_multi_draw_indirect_arb_draw_parameters); + case Technique.uniform_buffer_multi_draw_indirect_arb_draw_parameters: + indirect = true; + goto case(Technique.uniform_buffer_instanced);*/ + default:break; + } + + data_index = 0; + + int mesh_id = -1; + int material_id = -1; + int ubo_start = -1; + Texture texture; + uint item_ubo_id = 0; + + /*Buffer tmpb = ubos[0]; + ubos[0] = ubos[1]; + ubos[1] = tmpb; + + tmpb = batch_vbo[0]; + batch_vbo[0] = batch_vbo[1]; + batch_vbo[1] = tmpb; + + tmpb = batch_ibo[0]; + batch_ibo[0] = batch_ibo[1]; + batch_ibo[1] = tmpb;//*/ + //glFinish(); + + //glBeginQuery(GL_TIME_ELAPSED, time_queries[0]); + if(technique == Technique.vbo_batch) + { + uint items = item_id/16_384+1; + foreach(i; 0..items) + { + if(material_id != render_list[i].material_id) + { + material_id = render_list[i].material_id; + GfxConfig.materials[material_id].bind(); + } + if(texture.data != render_list[i].texture.data) + { + texture.data = render_list[i].texture.data; + render_list[i].texture.bind(); + } + + uint instance_count = 16_384; + if(i*16_384 > item_id) + { + instance_count = i*16_384 - item_id; + } + + /*glVertexAttribPointer(0,2,GL_FLOAT,false,16,cast(void*)(i*16_384*4*16)); + glVertexAttribPointer(1,2,GL_FLOAT,false,16,cast(void*)(i*16_384*4*16+8)); + + glDrawElements(GL_TRIANGLES,instance_count*6,GL_UNSIGNED_SHORT,cast(void*)(i*16_384*6*2));*/ + + glDrawElementsBaseVertex(GL_TRIANGLES,instance_count*6,GL_UNSIGNED_SHORT,cast(void*)(i*16_384*6*2),i*16_384*4); + } + } + else if(technique == Technique.ssbo_instanced || technique == Technique.instanced_attrib_divisor) + { + if(mesh_id != render_list[0].mesh_id) + { + mesh_id = render_list[0].mesh_id; + GfxConfig.meshes[mesh_id].bind(); + } + if(material_id != render_list[0].material_id) + { + material_id = render_list[0].material_id; + GfxConfig.materials[material_id].bind(); + } + if(texture.data != render_list[0].texture.data) + { + texture.data = render_list[0].texture.data; + render_list[0].texture.bind(); + } + glDrawArraysInstanced(GL_TRIANGLE_STRIP,0,4,item_id); + //glDrawElementsInstanced(GL_TRIANGLES,6,GL_UNSIGNED_SHORT,null,item_id); + } + else if(instanced) + { + uint items = item_id/992+1; + foreach(i; 0..items) + { + if(mesh_id != render_list[i].mesh_id) + { + mesh_id = render_list[i].mesh_id; + GfxConfig.meshes[mesh_id].bind(); + } + if(material_id != render_list[i].material_id) + { + material_id = render_list[i].material_id; + GfxConfig.materials[material_id].bind(); + } + if(texture.data != render_list[i].texture.data) + { + texture.data = render_list[0].texture.data; + render_list[i].texture.bind(); + } + ubos[0].bindRange(buffer_target,0,data_index,block_max_size); + + uint instance_count = 992; + if(i*992 > item_id) + { + instance_count = i*992 - item_id; + } + + /*if(indirect)glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, cast(void*)0, instance_count, 0); + else if(multi_draw)glMultiDrawElements(GL_TRIANGLES,cast(int*)multi_count.ptr,GL_UNSIGNED_SHORT,cast(void**)multi_offset.ptr,instance_count); + //glMultiDrawElementsBaseVertex(GL_TRIANGLES,cast(int*)multi_count.ptr,GL_UNSIGNED_SHORT,cast(void**)multi_offset.ptr,instance_count,cast(int*)multi_offset.ptr); + else */glDrawElementsInstanced(GL_TRIANGLES,6,GL_UNSIGNED_SHORT,null,instance_count); + //glDrawArraysInstanced(GL_TRIANGLES,0,6,instance_count); + data_index += data_offset * 992; + } + } + else + foreach(item; render_list[0..item_id]) + { + if(mesh_id != item.mesh_id) + { + mesh_id = item.mesh_id; + GfxConfig.meshes[mesh_id].bind(); + } + if(material_id != item.material_id) + { + material_id = item.material_id; + GfxConfig.materials[material_id].bind(); + GfxConfig.materials[material_id].pushBindings(); + } + if(texture.data != item.texture.data) + { + texture.data = render_list[0].texture.data; + item.texture.bind(); + } + + switch(technique) + { + case Technique.simple: + /*glUniform4f(0, *cast(float*)&uniform_block[data_index], *cast(float*)&uniform_block[data_index+4], *cast(float*)&uniform_block[data_index+8], *cast(float*)&uniform_block[data_index+12]); + glUniform4f(1, *cast(float*)&uniform_block[data_index+16], *cast(float*)&uniform_block[data_index+20], *cast(float*)&uniform_block[data_index+24], *cast(float*)&uniform_block[data_index+28]); + glUniform4f(2, *cast(float*)&uniform_block[data_index+32], *cast(float*)&uniform_block[data_index+36], *cast(float*)&uniform_block[data_index+40], *cast(float*)&uniform_block[data_index+44]); + */ + GfxConfig.materials[material_id].pushUniforms(&uniform_block[data_index]);break; + case Technique.simple_array: + glUniform4fv(0,12,cast(float*)(uniform_block.ptr+data_index)); + break; + case Technique.uniform_buffer: + ubos[0].bindRange(Buffer.BindTarget.uniform,0,data_index,data_offset); + break; + /*case Technique.uniform_buffer_draw_indirect: + ubos[0].bindRange(Buffer.BindTarget.uniform,0,data_index,data_offset); + glDrawElementsIndirect(GL_TRIANGLES,GL_UNSIGNED_SHORT,null); + data_index += data_offset; + continue;*/ + case Technique.uniform_buffer_indexed: + if(item_ubo_id >= 992) + { + item_ubo_id = 0; + ubo_start = data_index; + ubos[0].bindRange(Buffer.BindTarget.uniform,0,ubo_start,block_max_size); + } + glUniform1i(0,item_ubo_id++); + break; + default:break; + }//*/ + + /*version(ver3)ubos[0].bindRange(Buffer.BindTarget.uniform,0,data_index,data_offset); + else version(ver1) + { + glUniform4f(0, *cast(float*)&uniform_block[data_index], *cast(float*)&uniform_block[data_index+4], *cast(float*)&uniform_block[data_index+8], *cast(float*)&uniform_block[data_index+12]); + glUniform4f(1, *cast(float*)&uniform_block[data_index+16], *cast(float*)&uniform_block[data_index+20], *cast(float*)&uniform_block[data_index+24], *cast(float*)&uniform_block[data_index+28]); + glUniform4f(2, *cast(float*)&uniform_block[data_index+32], *cast(float*)&uniform_block[data_index+36], *cast(float*)&uniform_block[data_index+40], *cast(float*)&uniform_block[data_index+44]); + } + else version(ver2)glUniform4fv(0,12,cast(float*)(uniform_block.ptr+data_index)); + else version(ver4) + { + if(item_ubo_id >= 992) + { + item_ubo_id = 0; + ubo_start = data_index; + ubos[0].bindRange(Buffer.BindTarget.uniform,0,ubo_start,block_max_size); + } + glUniform1i(0,item_ubo_id++); + }//*/ + + glDrawElements(GL_TRIANGLES,6,GL_UNSIGNED_SHORT,null); + //glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + data_index += data_offset; + } + //glEndQuery(GL_TIME_ELAPSED); + //uint tmpq = time_queries[0]; + //time_queries[0] = time_queries[1]; + //time_queries[1] = tmpq; + /*Buffer tmpb = ubos[0]; + ubos[0] = ubos[1]; + ubos[1] = tmpb;//*/ + + data_index = 0; + //data_offset = 0; + item_id = 0; + //SDL_GL_SwapWindow(sdl_window); + //glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT); + //version(ver6)ubos[0].map(0, 64*MaxObjects, Buffer.BindTarget.uniform); + //ubos[0].map(Buffer.BindTarget.uniform); + + switch(technique) + { + case Technique.uniform_buffer_instanced_mapped_gl2: + ubos[0].map(Buffer.BindTarget.uniform); + //data_ptr = ubos[0].mappedPointer(); + break; + case Technique.uniform_buffer_instanced_mapped: + ubos[0].map(0, 64*MaxObjects, Buffer.BindTarget.uniform); + //data_ptr = ubos[0].mappedPointer(); + break; + default:break; + } + + if(ubos[0].data && ubos[0].mappedPointer) + { + data_ptr = ubos[0].mappedPointer; + } + + /*switch(technique) + { + case Technique.simple: + case Technique.simple_array: + case Technique.uniform_buffer: + case Technique.uniform_buffer_indexed: + case Technique.uniform_buffer_instanced: + case Technique.uniform_buffer_instanced_mapped: + case Technique.uniform_buffer_instanced_persistent_mapped: + default:break; + }*/ + } + glDisableVertexAttribArray(0); + glDisableVertexAttribArray(1); + /*glUseProgram(0); + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);*/ + //glDisable(GL_ALPHA_TEST); + } + + void resize(ivec2 size) + { + resolution = size; + dres = vec2(1.0/cast(float)size.x,1.0/cast(float)size.y); + } + + void view(vec2 pos, vec2 size) + { + view_pos = pos * size - 1; + view_size = vec2(2/size.x,2/size.y); + sdl_transform = vec4(0,0,1.0/size.x,1.0/size.y); + } + + static void function(ref Renderer this_, Texture tex, vec2 pos, vec2 size, vec4 coords, float angle, uint material_id, uint mesh_id) __draw; + static void function(ref Renderer this_) __present; + static void function(ref Renderer this_) __clear; + static void function(ref Renderer this_) __initialize; + + static void __loadBackend() + { + //this.technique = __ecs_used_technique; + if(technique == Technique.vbo_batch)__draw = &__draw_gl_vbo_batch; + else __draw = &__draw_gl; + __present = &__present_gl; + __clear = &__clear_gl; + __initialize = &__initialize_gl; + } + +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/shader.d b/demos/utils/source/ecs_utils/gfx/shader.d new file mode 100644 index 0000000..f7cd21a --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/shader.d @@ -0,0 +1,171 @@ +module ecs_utils.gfx.shader; + +import bindbc.sdl; + +import ecs.std; + +import glad.gl.gl; + +//version = ver1; + +struct Shader +{ + + void create() nothrow + { + data = Mallocator.make!Data; + } + + bool load(const char[] path) nothrow + { + if(data is null)data = Mallocator.make!Data; + + char[] cpath = (cast(char*)alloca(path.length+1))[0..path.length+1]; + cpath[0..$-1] = path[0..$]; + cpath[$-1] = 0; + + int ind = cast(int)path.length - 1; + for(;ind>0;ind--) + { + if(path[ind] == '.')break; + } + if(ind < 0)return false; + ind++; + if(ind + 2 > path.length)return false; + + char[2] ext = path[ind .. ind + 2]; + if(ext[0] == 'v' && ext[1] == 'p')data.type = Type.vertex; + else if(ext[0] == 'f' && ext[1] == 'p')data.type = Type.fragment; + else return false; + + SDL_RWops* file = SDL_RWFromFile(cpath.ptr,"r");//SDL_LoadFile(cpath.ptr,); + if(file) + { + size_t size = cast(size_t)SDL_RWsize(file); + data.code = Mallocator.makeArray!char(size+1); + data.code[$-1] = 0; + SDL_RWread(file,data.code.ptr,size,1); + + SDL_RWclose(file); + return true; + } + else return false; + + } + + bool compile() nothrow + { + switch(data.type) + { + case Type.vertex: + data.gl_handle = glCreateShader(GL_VERTEX_SHADER); + break; + case Type.fragment: + data.gl_handle = glCreateShader(GL_FRAGMENT_SHADER); + break; + default: return false; + } + + version(WebAssembly)const char* glsl = "#version 100\n"; + else const char* glsl = "#version 450\n"; + const char* buffer = data.code.ptr; + char* ver; + version(WebAssembly)ver = cast(char*)"#define ver1 1\n#define GLES\n".ptr; + else ver = cast(char*)"#define ver1 1\n".ptr; + /*switch(__ecs_used_technique) + { + case RenderTechnique.simple: + ver = cast(char*)"#define ver1 1\n".ptr; + break; + case RenderTechnique.simple_array: + ver = cast(char*)"#define ver2 1\n".ptr; + break; + case RenderTechnique.vbo_batch: + ver = cast(char*)"#define ver10 1\n".ptr; + break; + case RenderTechnique.instanced_attrib_divisor: + ver = cast(char*)"#define ver8 1\n".ptr; + break; + case RenderTechnique.uniform_buffer: + ver = cast(char*)"#define ver3 1\n".ptr; + break; + case RenderTechnique.uniform_buffer_indexed: + ver = cast(char*)"#define ver4 1\n".ptr; + break; + case RenderTechnique.uniform_buffer_multi_draw: + goto case(RenderTechnique.uniform_buffer_multi_draw_indirect); + case RenderTechnique.uniform_buffer_instanced: + ver = cast(char*)"#define ver5 1\n".ptr; + break; + case RenderTechnique.uniform_buffer_instanced_mapped_gl2: + goto case(RenderTechnique.uniform_buffer_instanced); + case RenderTechnique.uniform_buffer_instanced_mapped: + goto case(RenderTechnique.uniform_buffer_instanced); + case RenderTechnique.uniform_buffer_instanced_persistent_mapped: + goto case(RenderTechnique.uniform_buffer_instanced); + case RenderTechnique.uniform_buffer_instanced_persistent_mapped_coherent: + goto case(RenderTechnique.uniform_buffer_instanced); + case RenderTechnique.ssbo_instanced: + ver = cast(char*)"#define ver6 1\n".ptr; + break; + case RenderTechnique.uniform_buffer_draw_indirect: + goto case(RenderTechnique.uniform_buffer); + case RenderTechnique.uniform_buffer_multi_draw_indirect: + ver = cast(char*)"#define ver9 1\n".ptr; + break; + case RenderTechnique.uniform_buffer_multi_draw_indirect_arb_draw_parameters: + ver = cast(char*)"#define ver7 1\n".ptr; + break; + default:break; + }*/ + /*version(ver1)const char* ver = "#define ver1 1\n"; + version(ver2)const char* ver = "#define ver2 1\n"; + version(ver3)const char* ver = "#define ver3 1\n"; + version(ver4)const char* ver = "#define ver4 1\n"; + version(ver5)const char* ver = "#define ver5 1\n"; + version(ver6)const char* ver = "#define ver5 1\n";*/ + + const char*[3] input = [glsl,ver,buffer]; + + glShaderSource(data.gl_handle,3,input.ptr,null); + + glCompileShader(data.gl_handle); + + int compile; + glGetShaderiv(data.gl_handle,GL_COMPILE_STATUS,&compile); + if(compile == GL_FALSE) + { + SDL_Log("Shader compile error! %u %s",data.type,glsl); + return false; + } + + return true; + } + + void destroy() nothrow + { + if(data) + { + if(data.gl_handle)glDeleteShader(data.gl_handle); + Mallocator.dispose(data); + data = null; + } + } + + enum Type + { + vertex, + fragment, + geometry + } + + struct Data + { + char[] code; + Type type; + + uint gl_handle; + } + + Data* data; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/sprite.d b/demos/utils/source/ecs_utils/gfx/sprite.d new file mode 100644 index 0000000..06c0804 --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/sprite.d @@ -0,0 +1,11 @@ +module ecs_utils.gfx.sprite; + +import ecs_utils.math.matrix; +import ecs_utils.gfx.mesh_module; + +struct sprite +{ + MeshModule* mesh; + + mat3 matrix; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/texture.d b/demos/utils/source/ecs_utils/gfx/texture.d new file mode 100644 index 0000000..6f41fe2 --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/texture.d @@ -0,0 +1,118 @@ +module ecs_utils.gfx.texture; + +import bindbc.sdl; + +import ecs.std; + +import ecs_utils.math.vector; + +import glad.gl.gl; + +extern(C): + +struct Texture +{ + + void create() + { + data = Mallocator.make!Data; + } + + bool load(const char[] path) + { + char[] cpath = (cast(char*)alloca(path.length+1))[0..path.length+1]; + cpath[0..$-1] = path[0..$]; + cpath[$-1] = 0; + + return __load(this, cpath); + } + + /*static bool __load_sdl(ref Texture this_, const char[] path) + { + import ecs_utils.gfx.renderer; + SDL_Surface* surf = IMG_Load(path.ptr); + if(!surf)return false; + + this_.data.size = ivec2(surf.w,surf.h); + + this_.data.texture = SDL_CreateTextureFromSurface(Renderer.main_sdl_renderer,surf); + if(!this_.data.texture)return false; + //this_.data.texture = surf; + + return true; + }*/ + + static bool __load_gl(ref Texture this_, const char[] path) + { + SDL_Surface* surf = IMG_Load(path.ptr); + if(!surf)return false; + + with(this_) + { + data.size = ivec2(surf.w,surf.h); + data.bpp = surf.format.BytesPerPixel; + data.data = Mallocator.makeArray!ubyte(surf.w*surf.h*surf.format.BytesPerPixel); + data.data[0..$] = (cast(ubyte*)surf.pixels)[0..data.data.length]; + + glGenTextures(1, &data.gl_handle); + glBindTexture(GL_TEXTURE_2D,data.gl_handle); + + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + + if(data.bpp == 3)glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,surf.w,surf.h,0,GL_RGB,GL_UNSIGNED_BYTE,data.data.ptr); + else if(data.bpp == 4)glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,surf.w,surf.h,0,GL_RGBA,GL_UNSIGNED_BYTE,data.data.ptr); + else return false; + } + + + return true; + } + + void bind() + { + glActiveTexture(GL_TEXTURE0); + glBindTexture(GL_TEXTURE_2D, data.gl_handle); + } + + void destory() + { + if(data) + { + glDeleteTextures(1, &data.gl_handle); + Mallocator.dispose(data); + data = null; + } + } + + static bool function(ref Texture this_, const char[] path) __load; + + struct Data + { + ubyte[] data; + + ivec2 size; + uint bpp; + + union + { + SDL_Texture* texture; + uint gl_handle; + } + } + + static void __loadBackend() + { + __load = &__load_gl; + /*switch(backend) + { + case Backend.opengl:__load = &__load_gl;break; + case Backend.sdl:__load = &__load_sdl;break; + default:goto case(Backend.opengl); + }*/ + } + + Data* data; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/gfx/vertex.d b/demos/utils/source/ecs_utils/gfx/vertex.d new file mode 100644 index 0000000..1d11fdd --- /dev/null +++ b/demos/utils/source/ecs_utils/gfx/vertex.d @@ -0,0 +1,64 @@ +module ecs_utils.gfx.vertex; + +import ecs.std; + +struct Vertex +{ + void create() + { + data = Mallocator.make!Data; + } + + void bind() + { + + } + + void enableStates() + { + + } + + void attachBindings(scope Binding[] bindings) + { + data.bindings = Mallocator.makeArray(bindings); + } + + enum Type + { + byte_r_snorm, + byte_r_unorm, + byte_rg_snorm, + byte_rg_unorm, + byte_rgb_snorm, + byte_rgb_unorm, + byte_rgba_snorm, + byte_rgba_unorm, + short_r_snorm, + short_r_unorm, + short_rg_snorm, + short_rg_unorm, + short_rgb_snorm, + short_rgb_unorm, + short_rgba_snorm, + short_rgba_unorm, + float_r, + float_rg, + float_rgb, + float_rgba + } + + struct Binding + { + Type type; + uint stride; + } + + struct Data + { + Binding[] bindings; + uint size; + } + + Data* data; +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/imgui_bind.d b/demos/utils/source/ecs_utils/imgui_bind.d new file mode 100644 index 0000000..3e84328 --- /dev/null +++ b/demos/utils/source/ecs_utils/imgui_bind.d @@ -0,0 +1,508 @@ +module ecs_utils.imgui_bind; + +import bindbc.sdl; +import cimgui.cimgui; + +version(WebAssembly) +{ + extern(C): + bool ImGui_ImplOpenGL3_Init(const char* glsl_version = null); + void ImGui_ImplOpenGL3_Shutdown(); + void ImGui_ImplOpenGL3_NewFrame(); + void ImGui_ImplOpenGL3_RenderDrawData(ImDrawData* draw_data); + + bool ImGui_ImplSDL2_InitForOpenGL(SDL_Window* window, void* sdl_gl_context); + bool ImGui_ImplSDL2_InitForVulkan(SDL_Window* window); + bool ImGui_ImplSDL2_InitForD3D(SDL_Window* window); + void ImGui_ImplSDL2_Shutdown(); + void ImGui_ImplSDL2_NewFrame(SDL_Window* window); + bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event); +} +else : + +import bindbc.sdl; + +import glad.gl.gl; + +import cimgui.cimgui; + +extern(C): + +SDL_Window* g_Window; +ulong g_Time; +bool[3] g_MousePressed; +SDL_Cursor*[ImGuiMouseCursor_COUNT] g_MouseCursors; +char* g_ClipboardTextData; +GLuint g_FontTexture = 0; + +const (char)* ImGuiImplSDL2GetClipboardText(void*) +{ + if (g_ClipboardTextData) + SDL_free(g_ClipboardTextData); + g_ClipboardTextData = SDL_GetClipboardText(); + return g_ClipboardTextData; +} + +void ImGuiImplSDL2SetClipboardText(void*, const char* text) +{ + SDL_SetClipboardText(text); +} + +bool ImGui_ImplSDL2_ProcessEvent(const SDL_Event* event) +{ + ImGuiIO* io = igGetIO(); + switch (event.type) + { + case SDL_MOUSEWHEEL: + { + if (event.wheel.x > 0) io.MouseWheelH += 1; + if (event.wheel.x < 0) io.MouseWheelH -= 1; + if (event.wheel.y > 0) io.MouseWheel += 1; + if (event.wheel.y < 0) io.MouseWheel -= 1; + return true; + } + case SDL_MOUSEBUTTONDOWN: + { + if (event.button.button == SDL_BUTTON_LEFT) g_MousePressed[0] = true; + if (event.button.button == SDL_BUTTON_RIGHT) g_MousePressed[1] = true; + if (event.button.button == SDL_BUTTON_MIDDLE) g_MousePressed[2] = true; + return true; + } + case SDL_TEXTINPUT: + { + ImGuiIO_AddInputCharactersUTF8(io,event.text.text.ptr); + return true; + } + case SDL_KEYDOWN: + case SDL_KEYUP: + { + int key = event.key.keysym.scancode; + //IM_ASSERT(key >= 0 && key < IM_ARRAYSIZE(io.KeysDown)); + io.KeysDown[key] = (event.type == SDL_KEYDOWN); + io.KeyShift = ((SDL_GetModState() & KMOD_SHIFT) != 0); + io.KeyCtrl = ((SDL_GetModState() & KMOD_CTRL) != 0); + io.KeyAlt = ((SDL_GetModState() & KMOD_ALT) != 0); + io.KeySuper = ((SDL_GetModState() & KMOD_GUI) != 0); + return true; + } + default:break; + } + return false; +} + +bool ImGuiImplSDL2Init(SDL_Window* window) +{ + g_Window = window; + + // Setup back-end capabilities flags + ImGuiIO* io = igGetIO(); + io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional) + io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used) + io.BackendPlatformName = "imgui_impl_sdl"; + + // Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array. + io.KeyMap[ImGuiKey_Tab] = SDL_SCANCODE_TAB; + io.KeyMap[ImGuiKey_LeftArrow] = SDL_SCANCODE_LEFT; + io.KeyMap[ImGuiKey_RightArrow] = SDL_SCANCODE_RIGHT; + io.KeyMap[ImGuiKey_UpArrow] = SDL_SCANCODE_UP; + io.KeyMap[ImGuiKey_DownArrow] = SDL_SCANCODE_DOWN; + io.KeyMap[ImGuiKey_PageUp] = SDL_SCANCODE_PAGEUP; + io.KeyMap[ImGuiKey_PageDown] = SDL_SCANCODE_PAGEDOWN; + io.KeyMap[ImGuiKey_Home] = SDL_SCANCODE_HOME; + io.KeyMap[ImGuiKey_End] = SDL_SCANCODE_END; + io.KeyMap[ImGuiKey_Insert] = SDL_SCANCODE_INSERT; + io.KeyMap[ImGuiKey_Delete] = SDL_SCANCODE_DELETE; + io.KeyMap[ImGuiKey_Backspace] = SDL_SCANCODE_BACKSPACE; + io.KeyMap[ImGuiKey_Space] = SDL_SCANCODE_SPACE; + io.KeyMap[ImGuiKey_Enter] = SDL_SCANCODE_RETURN; + io.KeyMap[ImGuiKey_Escape] = SDL_SCANCODE_ESCAPE; + io.KeyMap[ImGuiKey_KeyPadEnter] = SDL_SCANCODE_RETURN2; + io.KeyMap[ImGuiKey_A] = SDL_SCANCODE_A; + io.KeyMap[ImGuiKey_C] = SDL_SCANCODE_C; + io.KeyMap[ImGuiKey_V] = SDL_SCANCODE_V; + io.KeyMap[ImGuiKey_X] = SDL_SCANCODE_X; + io.KeyMap[ImGuiKey_Y] = SDL_SCANCODE_Y; + io.KeyMap[ImGuiKey_Z] = SDL_SCANCODE_Z; + + io.SetClipboardTextFn = &ImGuiImplSDL2SetClipboardText; + io.GetClipboardTextFn = &ImGuiImplSDL2GetClipboardText; + io.ClipboardUserData = null; + + g_MouseCursors[ImGuiMouseCursor_Arrow] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_ARROW); + g_MouseCursors[ImGuiMouseCursor_TextInput] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_IBEAM); + g_MouseCursors[ImGuiMouseCursor_ResizeAll] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEALL); + g_MouseCursors[ImGuiMouseCursor_ResizeNS] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENS); + g_MouseCursors[ImGuiMouseCursor_ResizeEW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZEWE); + g_MouseCursors[ImGuiMouseCursor_ResizeNESW] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENESW); + g_MouseCursors[ImGuiMouseCursor_ResizeNWSE] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_SIZENWSE); + g_MouseCursors[ImGuiMouseCursor_Hand] = SDL_CreateSystemCursor(SDL_SYSTEM_CURSOR_HAND); + + //#ifdef _WIN32 + version(WebAssembly) + { + + } + else version(Windows) + { + SDL_SysWMinfo wmInfo; + SDL_VERSION(&wmInfo.version_); + SDL_GetWindowWMInfo(window, &wmInfo); + io.ImeWindowHandle = wmInfo.info.win.window; + } + //#else + //(void)window; + //#endif + + return true; +} + +bool ImGuiImplSDL2InitForOpenGL(SDL_Window* window, void* sdl_gl_context) +{ + //(void)sdl_gl_context; // Viewport branch will need this. + return ImGuiImplSDL2Init(window); +} + +void ImGuiImplSDL2Shutdown() +{ + g_Window = null; + + // Destroy last known clipboard data + if (g_ClipboardTextData) + SDL_free(g_ClipboardTextData); + g_ClipboardTextData = null; + + // Destroy SDL mouse cursors + for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++) + SDL_FreeCursor(g_MouseCursors[cursor_n]); + //memset(g_MouseCursors, 0, sizeof(g_MouseCursors)); +} + +static void ImGui_ImplSDL2_UpdateMousePosAndButtons() +{ + ImGuiIO* io = igGetIO(); + + // Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user) + if (io.WantSetMousePos) + SDL_WarpMouseInWindow(g_Window, cast(int)io.MousePos.x, cast(int)io.MousePos.y); + else + io.MousePos = ImVec2(-float.max, -float.max); + + int mx, my; + Uint32 mouse_buttons = SDL_GetMouseState(&mx, &my); + io.MouseDown[0] = g_MousePressed[0] || (mouse_buttons & (SDL_PRESSED<<(SDL_BUTTON_LEFT-1))) != 0; // If a mouse press event came, always pass it as "mouse held this frame", so we don't miss click-release events that are shorter than 1 frame. + io.MouseDown[1] = g_MousePressed[1] || (mouse_buttons & (SDL_PRESSED<<(SDL_BUTTON_RIGHT-1))) != 0; + io.MouseDown[2] = g_MousePressed[2] || (mouse_buttons & (SDL_PRESSED<<(SDL_BUTTON_MIDDLE-1))) != 0; + g_MousePressed[0] = g_MousePressed[1] = g_MousePressed[2] = false; + + //#if SDL_HAS_CAPTURE_AND_GLOBAL_MOUSE && !defined(__EMSCRIPTEN__) && !defined(__ANDROID__) && !(defined(__APPLE__) && TARGET_OS_IOS) + /*SDL_Window* focused_window = SDL_GetKeyboardFocus(); + if (g_Window == focused_window) + { + // SDL_GetMouseState() gives mouse position seemingly based on the last window entered/focused(?) + // The creation of a new windows at runtime and SDL_CaptureMouse both seems to severely mess up with that, so we retrieve that position globally. + int wx, wy; + SDL_GetWindowPosition(focused_window, &wx, &wy); + SDL_GetGlobalMouseState(&mx, &my); + mx -= wx; + my -= wy; + io.MousePos = ImVec2((float)mx, (float)my); + } + + // SDL_CaptureMouse() let the OS know e.g. that our imgui drag outside the SDL window boundaries shouldn't e.g. trigger the OS window resize cursor. + // The function is only supported from SDL 2.0.4 (released Jan 2016) + bool any_mouse_button_down = ImGui::IsAnyMouseDown(); + SDL_CaptureMouse(any_mouse_button_down ? SDL_TRUE : SDL_FALSE); +//#else*/ + if (SDL_GetWindowFlags(g_Window) & SDL_WINDOW_INPUT_FOCUS) + io.MousePos = ImVec2(cast(float)mx, cast(float)my); +//#endif +} + +static void ImGui_ImplSDL2_UpdateMouseCursor() +{ + ImGuiIO* io = igGetIO(); + if (io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) + return; + + ImGuiMouseCursor imgui_cursor = igGetMouseCursor(); + if (io.MouseDrawCursor || imgui_cursor == ImGuiMouseCursor_None) + { + // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor + SDL_ShowCursor(SDL_FALSE); + } + else + { + // Show OS mouse cursor + SDL_SetCursor(g_MouseCursors[imgui_cursor] ? g_MouseCursors[imgui_cursor] : g_MouseCursors[ImGuiMouseCursor_Arrow]); + SDL_ShowCursor(SDL_TRUE); + } +} + +static void ImGui_ImplSDL2_UpdateGamepads() +{ + ImGuiIO* io = igGetIO(); + //memset(io.NavInputs, 0, sizeof(io.NavInputs)); + if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0) + return; + + // Get gamepad + SDL_GameController* game_controller = SDL_GameControllerOpen(0); + if (!game_controller) + { + io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad; + return; + } + + // Update gamepad inputs + /*#define MAP_BUTTON(NAV_NO, BUTTON_NO) { io.NavInputs[NAV_NO] = (SDL_GameControllerGetButton(game_controller, BUTTON_NO) != 0) ? 1.0f : 0.0f; } + #define MAP_ANALOG(NAV_NO, AXIS_NO, V0, V1) { float vn = (float)(SDL_GameControllerGetAxis(game_controller, AXIS_NO) - V0) / (float)(V1 - V0); if (vn > 1.0f) vn = 1.0f; if (vn > 0.0f && io.NavInputs[NAV_NO] < vn) io.NavInputs[NAV_NO] = vn; } + const int thumb_dead_zone = 8000; // SDL_gamecontroller.h suggests using this value. + MAP_BUTTON(ImGuiNavInput_Activate, SDL_CONTROLLER_BUTTON_A); // Cross / A + MAP_BUTTON(ImGuiNavInput_Cancel, SDL_CONTROLLER_BUTTON_B); // Circle / B + MAP_BUTTON(ImGuiNavInput_Menu, SDL_CONTROLLER_BUTTON_X); // Square / X + MAP_BUTTON(ImGuiNavInput_Input, SDL_CONTROLLER_BUTTON_Y); // Triangle / Y + MAP_BUTTON(ImGuiNavInput_DpadLeft, SDL_CONTROLLER_BUTTON_DPAD_LEFT); // D-Pad Left + MAP_BUTTON(ImGuiNavInput_DpadRight, SDL_CONTROLLER_BUTTON_DPAD_RIGHT); // D-Pad Right + MAP_BUTTON(ImGuiNavInput_DpadUp, SDL_CONTROLLER_BUTTON_DPAD_UP); // D-Pad Up + MAP_BUTTON(ImGuiNavInput_DpadDown, SDL_CONTROLLER_BUTTON_DPAD_DOWN); // D-Pad Down + MAP_BUTTON(ImGuiNavInput_FocusPrev, SDL_CONTROLLER_BUTTON_LEFTSHOULDER); // L1 / LB + MAP_BUTTON(ImGuiNavInput_FocusNext, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER); // R1 / RB + MAP_BUTTON(ImGuiNavInput_TweakSlow, SDL_CONTROLLER_BUTTON_LEFTSHOULDER); // L1 / LB + MAP_BUTTON(ImGuiNavInput_TweakFast, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER); // R1 / RB + MAP_ANALOG(ImGuiNavInput_LStickLeft, SDL_CONTROLLER_AXIS_LEFTX, -thumb_dead_zone, -32768); + MAP_ANALOG(ImGuiNavInput_LStickRight, SDL_CONTROLLER_AXIS_LEFTX, +thumb_dead_zone, +32767); + MAP_ANALOG(ImGuiNavInput_LStickUp, SDL_CONTROLLER_AXIS_LEFTY, -thumb_dead_zone, -32767); + MAP_ANALOG(ImGuiNavInput_LStickDown, SDL_CONTROLLER_AXIS_LEFTY, +thumb_dead_zone, +32767); + + io.BackendFlags |= ImGuiBackendFlags_HasGamepad; + #undef MAP_BUTTON + #undef MAP_ANALOG*/ +} + + +private long frequency; + +void ImGuiImplSDL2NewFrame(SDL_Window* window) +{ + ImGuiIO* io = igGetIO(); + assert(ImFontAtlas_IsBuilt(io.Fonts), "Font atlas not built! It is generally built by the renderer back-end. Missing call to renderer _NewFrame() function? e.g. ImGui_ImplOpenGL3_NewFrame()."); + + // Setup display size (every frame to accommodate for window resizing) + int w, h; + int display_w, display_h; + SDL_GetWindowSize(window, &w, &h); + SDL_GL_GetDrawableSize(window, &display_w, &display_h); + io.DisplaySize = ImVec2(cast(float)w, cast(float)h); + if (w > 0 && h > 0) + io.DisplayFramebufferScale = ImVec2(cast(float)display_w / w, cast(float)display_h / h); + + // Setup time step (we don't use SDL_GetTicks() because it is using millisecond resolution) + frequency = SDL_GetPerformanceFrequency(); + long current_time = SDL_GetPerformanceCounter(); + io.DeltaTime = g_Time > 0 ? cast(float)(cast(double)(current_time - g_Time) / frequency) : cast(float)(1.0f / 60.0f); + g_Time = current_time; + + ImGui_ImplSDL2_UpdateMousePosAndButtons(); + ImGui_ImplSDL2_UpdateMouseCursor(); + + // Update game controllers (if enabled and available) + ImGui_ImplSDL2_UpdateGamepads(); +} + + + + + + + + + + +bool ImGuiImplOpenGL2Init() +{ + // Setup back-end capabilities flags + ImGuiIO* io = igGetIO(); + io.BackendRendererName = "imgui_impl_opengl2"; + return true; +} + +void ImGuiImplOpenGL2Shutdown() +{ + ImGuiImplOpenGL2DestroyDeviceObjects(); +} + +void ImGuiImplOpenGL2NewFrame() +{ + if (!g_FontTexture) + ImGuiImplOpenGL2CreateDeviceObjects(); +} + +static void ImGuiImplOpenGL2SetupRenderState(ImDrawData* draw_data, int fb_width, int fb_height) +{ + // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled, vertex/texcoord/color pointers, polygon fill. + glEnable(GL_BLEND); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glDisable(GL_CULL_FACE); + glDisable(GL_DEPTH_TEST); + //glDisable(GL_LIGHTING); + //glDisable(GL_COLOR_MATERIAL); + glEnable(GL_SCISSOR_TEST); + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + glEnable(GL_TEXTURE_2D); + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); + + // If you are using this code with non-legacy OpenGL header/contexts (which you should not, prefer using imgui_impl_opengl3.cpp!!), + // you may need to backup/reset/restore current shader using the lines below. DO NOT MODIFY THIS FILE! Add the code in your calling function: + // GLint last_program; + // glGetIntegerv(GL_CURRENT_PROGRAM, &last_program); + // glUseProgram(0); + // ImGui_ImplOpenGL2_RenderDrawData(...); + // glUseProgram(last_program) + + // Setup viewport, orthographic projection matrix + // Our visible imgui space lies from draw_data.DisplayPos (top left) to draw_data.DisplayPos+data_data.DisplaySize (bottom right). DisplayPos is (0,0) for single viewport apps. + glViewport(0, 0, cast(GLsizei)fb_width, cast(GLsizei)fb_height); + glMatrixMode(GL_PROJECTION); + glPushMatrix(); + glLoadIdentity(); + glOrtho(draw_data.DisplayPos.x, draw_data.DisplayPos.x + draw_data.DisplaySize.x, draw_data.DisplayPos.y + draw_data.DisplaySize.y, draw_data.DisplayPos.y, -1.0f, +1.0f); + glMatrixMode(GL_MODELVIEW); + glPushMatrix(); + glLoadIdentity(); +} + +// OpenGL2 Render function. +// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop) +// Note that this implementation is little overcomplicated because we are saving/setting up/restoring every OpenGL state explicitly, in order to be able to run within any OpenGL engine that doesn't do so. +void ImGuiImplOpenGL2RenderDrawData(ImDrawData* draw_data) +{ + // Avoid rendering when minimized, scale coordinates for retina displays (screen coordinates != framebuffer coordinates) + int fb_width = cast(int)(draw_data.DisplaySize.x * draw_data.FramebufferScale.x); + int fb_height = cast(int)(draw_data.DisplaySize.y * draw_data.FramebufferScale.y); + if (fb_width == 0 || fb_height == 0) + return; + + // Backup GL state + GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); + GLint[2] last_polygon_mode; glGetIntegerv(GL_POLYGON_MODE, last_polygon_mode.ptr); + GLint[4] last_viewport; glGetIntegerv(GL_VIEWPORT, last_viewport.ptr); + GLint[4] last_scissor_box; glGetIntegerv(GL_SCISSOR_BOX, last_scissor_box.ptr); + glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT); + + // Setup desired GL state + ImGuiImplOpenGL2SetupRenderState(draw_data, fb_width, fb_height); + + // Will project scissor/clipping rectangles into framebuffer space + ImVec2 clip_off = draw_data.DisplayPos; // (0,0) unless using multi-viewports + ImVec2 clip_scale = draw_data.FramebufferScale; // (1,1) unless using retina display which are often (2,2) + + // Render command lists + for (int n = 0; n < draw_data.CmdListsCount; n++) + { + ImDrawList* cmd_list = draw_data.CmdLists[n]; + ImDrawVert* vtx_buffer = cmd_list.VtxBuffer.Data; + ImDrawIdx* idx_buffer = cmd_list.IdxBuffer.Data; + glVertexPointer(2, GL_FLOAT, ImDrawVert.sizeof, cast(const GLvoid*)(cast(const char*)vtx_buffer + ImDrawVert.pos.offsetof)); + glTexCoordPointer(2, GL_FLOAT, ImDrawVert.sizeof, cast(const GLvoid*)(cast(const char*)vtx_buffer + ImDrawVert.uv.offsetof)); + glColorPointer(4, GL_UNSIGNED_BYTE, ImDrawVert.sizeof, cast(const GLvoid*)(cast(const char*)vtx_buffer + ImDrawVert.col.offsetof)); + + for (int cmd_i = 0; cmd_i < cmd_list.CmdBuffer.Size; cmd_i++) + { + const ImDrawCmd* pcmd = &cmd_list.CmdBuffer.Data[cmd_i]; + if (pcmd.UserCallback) + { + // User callback, registered via ImDrawList::AddCallback() + // (ImDrawCallback_ResetRenderState is a special callback value used by the user to request the renderer to reset render state.) + /*if (pcmd.UserCallback == &ImDrawCallback_ResetRenderState) + ImGui_ImplOpenGL2_SetupRenderState(draw_data, fb_width, fb_height); + else*/ + pcmd.UserCallback(cmd_list, pcmd); + } + else + { + // Project scissor/clipping rectangles into framebuffer space + ImVec4 clip_rect = ImVec4(0,0,0,0); + clip_rect.x = (pcmd.ClipRect.x - clip_off.x) * clip_scale.x; + clip_rect.y = (pcmd.ClipRect.y - clip_off.y) * clip_scale.y; + clip_rect.z = (pcmd.ClipRect.z - clip_off.x) * clip_scale.x; + clip_rect.w = (pcmd.ClipRect.w - clip_off.y) * clip_scale.y; + + if (clip_rect.x < fb_width && clip_rect.y < fb_height && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f) + { + // Apply scissor/clipping rectangle + glScissor(cast(int)clip_rect.x, cast(int)(fb_height - clip_rect.w), cast(int)(clip_rect.z - clip_rect.x), cast(int)(clip_rect.w - clip_rect.y)); + + // Bind texture, Draw + glBindTexture(GL_TEXTURE_2D, cast(GLuint)pcmd.TextureId); + glDrawElements(GL_TRIANGLES, cast(GLsizei)pcmd.ElemCount, ImDrawIdx.sizeof == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, idx_buffer); + } + } + idx_buffer += pcmd.ElemCount; + } + } + + // Restore modified GL state + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); + glBindTexture(GL_TEXTURE_2D, cast(GLuint)last_texture); + glMatrixMode(GL_MODELVIEW); + glPopMatrix(); + glMatrixMode(GL_PROJECTION); + glPopMatrix(); + glPopAttrib(); + glPolygonMode(GL_FRONT, cast(GLenum)last_polygon_mode[0]); glPolygonMode(GL_BACK, cast(GLenum)last_polygon_mode[1]); + glViewport(last_viewport[0], last_viewport[1], cast(GLsizei)last_viewport[2], cast(GLsizei)last_viewport[3]); + glScissor(last_scissor_box[0], last_scissor_box[1], cast(GLsizei)last_scissor_box[2], cast(GLsizei)last_scissor_box[3]); +} + +bool ImGuiImplOpenGL2CreateFontsTexture() +{ + // Build texture atlas + ImGuiIO* io = igGetIO(); + ubyte* pixels; + int width, height; + int bpp; + ImFontAtlas_GetTexDataAsRGBA32(io.Fonts, &pixels, &width, &height, &bpp); // Load as RGBA 32-bits (75% of the memory is wasted, but default font is so small) because it is more likely to be compatible with user's existing shaders. If your ImTextureId represent a higher-level concept than just a GL texture id, consider calling GetTexDataAsAlpha8() instead to save on GPU memory. + + // Upload texture to graphics system + GLint last_texture; + glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture); + glGenTextures(1, &g_FontTexture); + glBindTexture(GL_TEXTURE_2D, g_FontTexture); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels); + + // Store our identifier + io.Fonts.TexID = cast(ImTextureID)g_FontTexture; + + // Restore state + glBindTexture(GL_TEXTURE_2D, last_texture); + + return true; +} + +void ImGuiImplOpenGL2DestroyFontsTexture() +{ + if (g_FontTexture) + { + ImGuiIO* io = igGetIO(); + glDeleteTextures(1, &g_FontTexture); + io.Fonts.TexID = null; + g_FontTexture = 0; + } +} + +bool ImGuiImplOpenGL2CreateDeviceObjects() +{ + return ImGuiImplOpenGL2CreateFontsTexture(); +} + +void ImGuiImplOpenGL2DestroyDeviceObjects() +{ + ImGuiImplOpenGL2DestroyFontsTexture(); +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/imgui_styles.d b/demos/utils/source/ecs_utils/imgui_styles.d new file mode 100644 index 0000000..0520ec6 --- /dev/null +++ b/demos/utils/source/ecs_utils/imgui_styles.d @@ -0,0 +1,95 @@ +module ecs_utils.imgui_styles; + +import cimgui.cimgui; + +void setStyle(uint index) +{ + ImGuiStyle * style = igGetStyle(); + ImVec4 * colors = style.Colors.ptr; + + switch(index) + { + case 0: + igStyleColorsClassic(style); + break; + case 1: + igStyleColorsDark(style); + break; + case 2: + igStyleColorsLight(style); + break; + case 3: + colors[ImGuiCol_Text] = ImVec4(0.95f, 0.96f, 0.98f, 1.00f); + colors[ImGuiCol_TextDisabled] = ImVec4(0.36f, 0.42f, 0.47f, 1.00f); + colors[ImGuiCol_WindowBg] = ImVec4(0.11f, 0.15f, 0.17f, 1.00f); + colors[ImGuiCol_ChildBg] = ImVec4(0.15f, 0.18f, 0.22f, 1.00f); + colors[ImGuiCol_PopupBg] = ImVec4(0.08f, 0.08f, 0.08f, 0.94f); + colors[ImGuiCol_Border] = ImVec4(0.08f, 0.10f, 0.12f, 1.00f); + colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f); + colors[ImGuiCol_FrameBg] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f); + colors[ImGuiCol_FrameBgHovered] = ImVec4(0.12f, 0.20f, 0.28f, 1.00f); + colors[ImGuiCol_FrameBgActive] = ImVec4(0.09f, 0.12f, 0.14f, 1.00f); + colors[ImGuiCol_TitleBg] = ImVec4(0.09f, 0.12f, 0.14f, 0.65f); + colors[ImGuiCol_TitleBgActive] = ImVec4(0.08f, 0.10f, 0.12f, 1.00f); + colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.00f, 0.00f, 0.00f, 0.51f); + colors[ImGuiCol_MenuBarBg] = ImVec4(0.15f, 0.18f, 0.22f, 1.00f); + colors[ImGuiCol_ScrollbarBg] = ImVec4(0.02f, 0.02f, 0.02f, 0.39f); + colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f); + colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.18f, 0.22f, 0.25f, 1.00f); + colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.09f, 0.21f, 0.31f, 1.00f); + colors[ImGuiCol_CheckMark] = ImVec4(0.28f, 0.56f, 1.00f, 1.00f); + colors[ImGuiCol_SliderGrab] = ImVec4(0.28f, 0.56f, 1.00f, 1.00f); + colors[ImGuiCol_SliderGrabActive] = ImVec4(0.37f, 0.61f, 1.00f, 1.00f); + colors[ImGuiCol_Button] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f); + colors[ImGuiCol_ButtonHovered] = ImVec4(0.28f, 0.56f, 1.00f, 1.00f); + colors[ImGuiCol_ButtonActive] = ImVec4(0.06f, 0.53f, 0.98f, 1.00f); + colors[ImGuiCol_Header] = ImVec4(0.20f, 0.25f, 0.29f, 0.55f); + colors[ImGuiCol_HeaderHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f); + colors[ImGuiCol_HeaderActive] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f); + colors[ImGuiCol_Separator] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f); + colors[ImGuiCol_SeparatorHovered] = ImVec4(0.10f, 0.40f, 0.75f, 0.78f); + colors[ImGuiCol_SeparatorActive] = ImVec4(0.10f, 0.40f, 0.75f, 1.00f); + colors[ImGuiCol_ResizeGrip] = ImVec4(0.26f, 0.59f, 0.98f, 0.25f); + colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.67f); + colors[ImGuiCol_ResizeGripActive] = ImVec4(0.26f, 0.59f, 0.98f, 0.95f); + colors[ImGuiCol_Tab] = ImVec4(0.11f, 0.15f, 0.17f, 1.00f); + colors[ImGuiCol_TabHovered] = ImVec4(0.26f, 0.59f, 0.98f, 0.80f); + colors[ImGuiCol_TabActive] = ImVec4(0.20f, 0.25f, 0.29f, 1.00f); + colors[ImGuiCol_TabUnfocused] = ImVec4(0.11f, 0.15f, 0.17f, 1.00f); + colors[ImGuiCol_TabUnfocusedActive] = ImVec4(0.11f, 0.15f, 0.17f, 1.00f); + colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f); + colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f); + colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f); + colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f); + colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f); + colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f); + colors[ImGuiCol_NavHighlight] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f); + colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f); + colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f); + colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f); + + style.PopupRounding = 3; + + style.WindowPadding = ImVec2(4, 4); + style.FramePadding = ImVec2(6, 4); + style.ItemSpacing = ImVec2(6, 2); + + style.ScrollbarSize = 18; + + style.WindowBorderSize = 1; + style.ChildBorderSize = 1; + style.PopupBorderSize = 1; + style.FrameBorderSize = 0; + + style.WindowRounding = 3; + style.ChildRounding = 3; + style.FrameRounding = 4; + style.ScrollbarRounding = 2; + style.GrabRounding = 4; + break; + default: + igStyleColorsClassic(style); + break; + } + +} \ No newline at end of file diff --git a/demos/utils/source/ecs_utils/utils.d b/demos/utils/source/ecs_utils/utils.d new file mode 100644 index 0000000..aa223eb --- /dev/null +++ b/demos/utils/source/ecs_utils/utils.d @@ -0,0 +1,183 @@ +module ecs_utils.utils; + +extern(C): + +int randomRange(int min, int max) +{ + int range = max - min; + return rand() % range - min; +} + +float randomf() +{ + const float scale = 1.0 / 32_767.0; + return cast(float)(rand() & 0x007FFF) * scale; +} + +/* +float randomRangef(float min, float max) +{ + //int range = max - min; + return rand()%4096; +}*/ + +extern(C) int printf(scope const char* format, ...) @nogc nothrow @system; +extern(C) int rand(); + +version(D_BetterC) +{ + version(LDC) + { + extern(C) bool _d_enter_cleanup(void*) + { + return true; + } + + extern(C) void _d_leave_cleanup(void*) + { + + } + + extern(C) void _d_array_slice_copy(void* dst, size_t dstlen, void* src, size_t srclen, size_t elemsz) + { + import ldc.intrinsics : llvm_memcpy; + llvm_memcpy!size_t(dst, src, dstlen * elemsz, 0); + } + } +} + + + +version(WebAssembly) +{ + + enum EMSCRIPTEN_RESULT_SUCCESS = 0; + enum EMSCRIPTEN_RESULT_DEFERRED = 1; + enum EMSCRIPTEN_RESULT_NOT_SUPPORTED = -1; + enum EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED = -2; + enum EMSCRIPTEN_RESULT_INVALID_TARGET = -3; + enum EMSCRIPTEN_RESULT_UNKNOWN_TARGET = -4; + enum EMSCRIPTEN_RESULT_INVALID_PARAM = -5; + enum EMSCRIPTEN_RESULT_FAILED = -6; + enum EMSCRIPTEN_RESULT_NO_DATA = -7; + enum EMSCRIPTEN_RESULT_TIMED_OUT = -8; + + alias EMSCRIPTEN_FULLSCREEN_SCALE = int; + enum EMSCRIPTEN_FULLSCREEN_SCALE_DEFAULT = 0; + enum EMSCRIPTEN_FULLSCREEN_SCALE_STRETCH = 1; + enum EMSCRIPTEN_FULLSCREEN_SCALE_ASPECT = 2; + enum EMSCRIPTEN_FULLSCREEN_SCALE_CENTER = 3; + + alias EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE = int; + enum EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_NONE = 0; + enum EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_STDDEF = 1; + enum EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE_HIDEF = 2; + + alias EMSCRIPTEN_FULLSCREEN_FILTERING = int; + enum EMSCRIPTEN_FULLSCREEN_FILTERING_DEFAULT = 0; + enum EMSCRIPTEN_FULLSCREEN_FILTERING_NEAREST = 1; + enum EMSCRIPTEN_FULLSCREEN_FILTERING_BILINEAR = 2; + + alias em_canvasresized_callback_func = extern(C) bool function (int eventType, const void *reserved, void *userData); + + struct EmscriptenFullscreenStrategy { + EMSCRIPTEN_FULLSCREEN_SCALE scaleMode; + EMSCRIPTEN_FULLSCREEN_CANVAS_SCALE canvasResolutionScaleMode; + EMSCRIPTEN_FULLSCREEN_FILTERING filteringMode; + em_canvasresized_callback_func canvasResizedCallback; + void *canvasResizedCallbackUserData; + } + + extern (C) const (char)* emscripten_result_to_string(int result) { + if (result == EMSCRIPTEN_RESULT_SUCCESS) return "EMSCRIPTEN_RESULT_SUCCESS"; + if (result == EMSCRIPTEN_RESULT_DEFERRED) return "EMSCRIPTEN_RESULT_DEFERRED"; + if (result == EMSCRIPTEN_RESULT_NOT_SUPPORTED) return "EMSCRIPTEN_RESULT_NOT_SUPPORTED"; + if (result == EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED) return "EMSCRIPTEN_RESULT_FAILED_NOT_DEFERRED"; + if (result == EMSCRIPTEN_RESULT_INVALID_TARGET) return "EMSCRIPTEN_RESULT_INVALID_TARGET"; + if (result == EMSCRIPTEN_RESULT_UNKNOWN_TARGET) return "EMSCRIPTEN_RESULT_UNKNOWN_TARGET"; + if (result == EMSCRIPTEN_RESULT_INVALID_PARAM) return "EMSCRIPTEN_RESULT_INVALID_PARAM"; + if (result == EMSCRIPTEN_RESULT_FAILED) return "EMSCRIPTEN_RESULT_FAILED"; + if (result == EMSCRIPTEN_RESULT_NO_DATA) return "EMSCRIPTEN_RESULT_NO_DATA"; + return "Unknown EMSCRIPTEN_RESULT!"; + } + + extern (C) alias em_callback_func = void function(); + extern (C) alias em_arg_callback_func = void function(void*); + extern (C) void emscripten_set_main_loop(em_callback_func func, int fps, int simulate_infinite_loop); + extern (C) void emscripten_set_main_loop_arg(em_arg_callback_func func, void *arg, int fps, int simulate_infinite_loop); + extern (C) int emscripten_set_main_loop_timing(int mode, int value); + extern (C) void emscripten_cancel_main_loop(); + extern (C) int emscripten_request_fullscreen_strategy(const char *target, bool deferUntilInEventHandler, const EmscriptenFullscreenStrategy *fullscreenStrategy); + extern (C) int emscripten_enter_soft_fullscreen(const char *target, const EmscriptenFullscreenStrategy *fullscreenStrategy); + + alias int time_t; + alias int clockid_t; + enum CLOCK_REALTIME = 0; + + struct timespec + { + time_t tv_sec; + int tv_nsec; + } + + extern(C) int clock_gettime(clockid_t, timespec*) @nogc nothrow @system; + + struct Time + { + + + static long getUSecTime() + { + time_t time; + timespec spec; + + clock_gettime(CLOCK_REALTIME, &spec); + + //time = spec.tv_sec; + return spec.tv_sec * 1000_000 + spec.tv_nsec / 1000;//time / 1000_000; + + /*LARGE_INTEGER time, freq; + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(&time); + return time.QuadPart / (freq.QuadPart / 1000_000);*/ + } + } +} +else version(Windows) +{ + import core.stdc.stdio : printf; + import core.sys.windows.windows; + struct Time + { + static long getUSecTime() + { + LARGE_INTEGER time, freq; + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(&time); + return time.QuadPart / (freq.QuadPart / 1000_000); + } + } +} +else version(Posix) +{ + import core.stdc.stdio : printf; + import core.sys.posix.time; + struct Time + { + static long getUSecTime() + { + time_t time; + timespec spec; + + clock_gettime(CLOCK_REALTIME, &spec); + + //time = spec.tv_sec; + return spec.tv_sec * 1000_000 + spec.tv_nsec / 1000;//time / 1000_000; + + /*LARGE_INTEGER time, freq; + QueryPerformanceFrequency(&freq); + QueryPerformanceCounter(&time); + return time.QuadPart / (freq.QuadPart / 1000_000);*/ + } + } +} \ No newline at end of file diff --git a/dub.json b/dub.json index e4d9704..87b9b7b 100755 --- a/dub.json +++ b/dub.json @@ -10,6 +10,9 @@ "dflagss": [ "-betterC" ], + "excludedSourceFiles":[ + "source\/ecs\/traits.d" + ], "configurations" : [ { "name" : "library", diff --git a/source/ecs/vector.d b/source/ecs/vector.d index 84ecc51..fa616ed 100644 --- a/source/ecs/vector.d +++ b/source/ecs/vector.d @@ -29,7 +29,7 @@ public: } - /*static if (isCopyable!T) { + static if (isCopyable!T) { export this(this) { T[] tmp = array[0 .. used]; array = null; @@ -38,9 +38,9 @@ public: } } else { @disable this(this); - }*/ + } - @disable this(this); + //@disable this(this); export ~this() { clear();