Commits

Jason McKesson committed 1d81399 Merge

Merge with default

  • Participants
  • Parent commits 70f811f, 419cae3
  • Branches 0.4
  • Tags 0.4.4

Comments (0)

Files changed (65)

+16cc456e61d48b050e5b7476fcdd84cbfc229e95 latest-spec
+926319cc3c444d01d36a55b11068dd1d2410b834 0.3.0
+5a0e965d3e97604e9076b49cf7de6af6ff96e71a 0.3.1
+696b74d38caa8a24970da51d607be7abf97bc6e5 0.4.0
+696b74d38caa8a24970da51d607be7abf97bc6e5 0.4.0
+8f27255e791af3ecab21c43d9b17eef008af2eb1 0.4.0
+8f27255e791af3ecab21c43d9b17eef008af2eb1 0.4.0
+bc6f7cd92cefdf937ae63dbbc124818dac16aa81 0.4.0
+bc6f7cd92cefdf937ae63dbbc124818dac16aa81 0.4.0
+6b2adf0b17eff5eeee00cda855f0e43dc4652fb1 0.4.0
+6b2adf0b17eff5eeee00cda855f0e43dc4652fb1 0.4.0
+3602343eb20f7aaf7bcc9fde5b34f3de1cc57a2e 0.4.0
+8d5fd3371296b8360b2842de8278fa71fc4effb2 0.4.1
+8d5fd3371296b8360b2842de8278fa71fc4effb2 0.4.1
+f695602f9a3f4f8e569c3b416d6be1690de1aee2 0.4.1
+ab147fdcc6dfe396b5bf8dc7d6f31449164884b3 0.4.2
 16cc456e61d48b050e5b7476fcdd84cbfc229e95 latest-spec
-926319cc3c444d01d36a55b11068dd1d2410b834 0.3.0
-5a0e965d3e97604e9076b49cf7de6af6ff96e71a 0.3.1
-696b74d38caa8a24970da51d607be7abf97bc6e5 0.4.0
-696b74d38caa8a24970da51d607be7abf97bc6e5 0.4.0
-8f27255e791af3ecab21c43d9b17eef008af2eb1 0.4.0
-8f27255e791af3ecab21c43d9b17eef008af2eb1 0.4.0
-bc6f7cd92cefdf937ae63dbbc124818dac16aa81 0.4.0
-bc6f7cd92cefdf937ae63dbbc124818dac16aa81 0.4.0
-6b2adf0b17eff5eeee00cda855f0e43dc4652fb1 0.4.0
-6b2adf0b17eff5eeee00cda855f0e43dc4652fb1 0.4.0
-3602343eb20f7aaf7bcc9fde5b34f3de1cc57a2e 0.4.0
-8d5fd3371296b8360b2842de8278fa71fc4effb2 0.4.1
-8d5fd3371296b8360b2842de8278fa71fc4effb2 0.4.1
-f695602f9a3f4f8e569c3b416d6be1690de1aee2 0.4.1
-ab147fdcc6dfe396b5bf8dc7d6f31449164884b3 0.4.2
+a6557523a1d6447497aaf3126f775f085dd18dc7 latest-spec
+fe2569efc16ff94abb607aeb13a1bff9203e4932 0.4.4

File docs/glsdk.doxy

 
 Bugs or feature requests should be filed in the <a href="https://bitbucket.org/alfonse/unofficial-opengl-sdk/issues?status=new&status=open">Bitbucket issue tracker</a> for the SDK. However, bugs can also be filed on the SourceForge issue tracker. Questions or other inquiries can be directed to the <a href="http://www.opengl.org/discussion_boards/">OpenGL forums</a>.
 
-\section mainpage_notation Notation
+You can look on the \ref module_troubleshooting "troubleshooting page" for information about combating common problems.
+
+\section mainpage_notation Request for Aid
 
 The Unofficial GL SDK is still in Alpha at present. Currently, the SDK is missing the following libraries:
 
 \li \a freeglut: FreeGLUT
 \li \a glm: GLM
 
+Note that all of the libraries are built linking non-statically to the C++ runtime libraries (where available on the platform). Therefore, you should not use the <tt>StaticRuntime</tt> flag in Premake4.
+
 \section page_use_native Native Build
 
 If you wish to natively link to the SDK libraries, but do not use Premake to generate your build files, you will have to do a bit of extra work. Each library has its own include paths and so forth.
 
 This section assumes that you are familiar with your build tools. You should know how to link to static library files, add directories to your include path, and add defines to your build on a per-project basis.
 
+All of the libraries are built linking non-statically to the C++ runtime libraries (where available on the platform). Therefore, any code using these libraries must do the same.
+
 The libraries use the same basic names for GCC-based builds as Visual Studio builds, but they have different extensions and prefixes. The VS libraries end in ".lib", while the GCC libraries end in ".a". The VS libraries have no prefix, while the GCC versions all begin with "lib".
 
 So, if there was a library named "thingD", the GCC version would be "libthingD.a", while the VS version would be "thingD.lib".

File docs/modules.doxy

 
 **/
 
+/**
+\defgroup module_troubleshooting Troubleshooting
+
+@section trouble_headers Header Inclusion Order
+
+Headers must be included in certain orders. GLFW and FreeGLUT headers must be included \em after including one of the GL Load OpenGL headers. For example, if you want to use OpenGL 3.3 core with FreeGLUT, you must include them in this order:
+
+\code
+#include <glload/gl_3_3.h>
+#include <GL/freeglut.h>
+\endcode
+
+This is because FreeGLUT requires some of the types defined in the GL Load headers. Normally, it would include <tt>GL/gl.h</tt> directly, but since GL Load cannot work with the old header, we have to forcibly include it outselves first.
+
+The same goes for GLEW.
+
+The GLimg library headers <em>do not</em> require the inclusion of any GL Load headers. Some of the Texture Generation functions return <tt>unsigned int</tt> instead of actual GLenum values in order to support this.
+
+GL Util and GL Mesh headers can require GL Load inclusion on a case-by-case basis. Each file that requires it will have a notation in the documentation for that particular header file. Thus, if you include glutil.h or glmesh.h, you \em need to include a GL Load header first.
+
+A good rule of thumb is to simply include the GL Load headers before including \em anything else from the SDK.
+**/
+

File examples/font_test/font_test.cpp

+
+#include <string>
+#include <vector>
+#include <deque>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <glload/gl_3_3.hpp>
+#include <glload/gll.hpp>
+#include <GL/glfw.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glutil/glutil.h>
+#include <glmesh/glmesh.h>
+
+GLint g_cameraToClipMatrixUnif = 0;
+
+GLuint g_program = 0;
+
+void InitializeProgram()
+{
+	const std::string vertexShader(
+		"#version 330\n"
+		"\n"
+		"layout(location = 0) in vec4 position;\n"
+		"layout(location = 1) in vec4 texCoord;\n"
+		"\n"
+		"smooth out vec2 glyphCoord;\n"
+		"\n"
+		"uniform mat4 cameraToClipMatrix;\n"
+		"\n"
+		"void main()\n"
+		"{\n"
+		"	gl_Position = cameraToClipMatrix * position;\n"
+		"	glyphCoord = texCoord.st;\n"
+		"}\n"
+		);
+
+	const std::string fragmentShader(
+		"#version 330\n"
+		"\n"
+		"smooth in vec2 glyphCoord;\n"
+		"out vec4 outputColor;\n"
+		"uniform sampler2D glyphTex;"
+		"\n"
+		"void main()\n"
+		"{\n"
+		"	outputColor = texture(glyphTex, glyphCoord).rrrr;\n"
+		"}\n"
+		);
+
+	GLuint vertShader = glutil::CompileShader(gl::GL_VERTEX_SHADER, vertexShader);
+	GLuint fragShader = glutil::CompileShader(gl::GL_FRAGMENT_SHADER, fragmentShader);
+
+	g_program = glutil::LinkProgram(vertShader, fragShader);
+
+	gl::DeleteShader(vertShader);
+	gl::DeleteShader(fragShader);
+
+	g_cameraToClipMatrixUnif = gl::GetUniformLocation(g_program, "cameraToClipMatrix");
+	GLint samplerUnif = gl::GetUniformLocation(g_program, "glyphTex");
+	gl::UseProgram(g_program);
+	gl::Uniform1i(samplerUnif, 0);
+	gl::UseProgram(0);
+}
+
+GLuint g_dataBufferObject;
+GLuint g_vao;
+
+glutil::Font *g_pFont = NULL;
+glmesh::VertexFormat *g_pVertFmt = NULL;
+glmesh::StreamBuffer *g_pStreamBuf = NULL;
+
+GLuint g_numGlyphsToDraw = 0;
+
+void PushGlyph( std::vector<GLfloat> &vecVertex, int loop, std::vector<glm::vec2> &positions,
+			   std::vector<glm::vec2> &texCoords )
+{
+	vecVertex.push_back(positions[loop].x);
+	vecVertex.push_back(positions[loop].y);
+	vecVertex.push_back(texCoords[loop].x);
+	vecVertex.push_back(texCoords[loop].y);
+}
+
+void AddGlyph(std::vector<GLfloat> &vecVertex, const glutil::GlyphQuad &theGlyph)
+{
+	std::vector<glm::vec2> positions = theGlyph.GetPositions();
+	std::vector<glm::vec2> texCoords = theGlyph.GetTexCoords();
+
+	PushGlyph(vecVertex, 0, positions, texCoords);
+	PushGlyph(vecVertex, 1, positions, texCoords);
+	PushGlyph(vecVertex, 2, positions, texCoords);
+
+	PushGlyph(vecVertex, 1, positions, texCoords);
+	PushGlyph(vecVertex, 3, positions, texCoords);
+	PushGlyph(vecVertex, 2, positions, texCoords);
+}
+
+void SendVerts(glmesh::Draw &imm, int index, std::vector<glm::vec2> &positions,
+			   std::vector<glm::vec2> &texCoords)
+{
+	imm.Attrib(positions[index]);
+	imm.Attrib(texCoords[index]);
+}
+
+void DrawGlyph(glmesh::Draw &imm, const glutil::GlyphQuad &theGlyph)
+{
+	std::vector<glm::vec2> positions = theGlyph.GetPositions();
+	std::vector<glm::vec2> texCoords = theGlyph.GetTexCoords();
+
+	SendVerts(imm, 0, positions, texCoords);
+	SendVerts(imm, 1, positions, texCoords);
+	SendVerts(imm, 2, positions, texCoords);
+
+	SendVerts(imm, 1, positions, texCoords);
+	SendVerts(imm, 3, positions, texCoords);
+	SendVerts(imm, 2, positions, texCoords);
+}
+
+std::string GetString()
+{
+	return "Test string";
+}
+
+void InitializeVertexData()
+{
+	glmesh::AttributeList attribs;
+	//First attribute is attribute index 0, a vec4 of floats.
+	attribs.push_back(glmesh::AttribDesc(0, 2, glmesh::VDT_SINGLE_FLOAT, glmesh::ADT_FLOAT));
+	//Second attribute is attribute index 1, a vec4 of normalized, unsigned bytes.
+	attribs.push_back(glmesh::AttribDesc(1, 2, glmesh::VDT_SINGLE_FLOAT, glmesh::ADT_FLOAT));
+
+	g_pVertFmt = new glmesh::VertexFormat(attribs);
+	g_pStreamBuf = new glmesh::StreamBuffer(1024 * 1024);
+
+	
+
+	std::vector<GLfloat> vecVertex;
+
+	std::string theText = GetString();
+
+	std::vector<glutil::GlyphQuad> glyphs = g_pFont->LayoutLine(theText.c_str(), theText.size(),
+		glm::vec2(50.0f, 250.0f), glutil::REF_BASELINE);
+
+	vecVertex.reserve(24 * glyphs.size());
+
+	assert(glyphs.size());
+
+	for(size_t loop = 0; loop < glyphs.size(); ++loop)
+		AddGlyph(vecVertex, glyphs[loop]);
+
+	g_numGlyphsToDraw = glyphs.size();
+
+	gl::GenBuffers(1, &g_dataBufferObject);
+
+	gl::BindBuffer(gl::GL_ARRAY_BUFFER, g_dataBufferObject);
+	gl::BufferData(gl::GL_ARRAY_BUFFER, sizeof(GLfloat) * vecVertex.size(), &vecVertex[0], gl::GL_STATIC_DRAW);
+
+	gl::GenVertexArrays(1, &g_vao);
+
+	gl::BindVertexArray(g_vao);
+	gl::BindBuffer(gl::GL_ARRAY_BUFFER, g_dataBufferObject);
+	gl::EnableVertexAttribArray(0);
+	gl::VertexAttribPointer(0, 2, gl::GL_FLOAT, gl::GL_FALSE, 4 * sizeof(GLfloat), (void*)0);
+	gl::EnableVertexAttribArray(1);
+	gl::VertexAttribPointer(1, 2, gl::GL_FLOAT, gl::GL_FALSE, 4 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
+
+	gl::BindVertexArray(0);
+	gl::BindBuffer(gl::GL_ARRAY_BUFFER, 0);
+}
+
+//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
+void init()
+{
+	g_pFont = glutil::GenerateFont(glutil::FONT_SIZE_LARGE);
+
+	InitializeProgram();
+	InitializeVertexData();
+}
+
+glm::ivec2 g_windowSize(500, 500);
+
+typedef std::deque<std::string> StringQueue;
+
+std::string g_currString;
+StringQueue g_strings;
+
+void DrawTextString(const std::string &text, const glm::vec2 &location)
+{
+	std::vector<glutil::GlyphQuad> glyphs = g_pFont->LayoutLine(text.c_str(), text.size(),
+		location, glutil::REF_BOTTOM);
+
+	glmesh::Draw imm(gl::GL_TRIANGLES, glyphs.size() * 6, *g_pVertFmt, *g_pStreamBuf);
+
+	for(size_t loop = 0; loop < glyphs.size(); ++loop)
+	{
+		DrawGlyph(imm, glyphs[loop]);
+	}
+}
+
+//Called to update the display.
+//You should call glutSwapBuffers after all of your rendering to display what you rendered.
+//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
+void display()
+{
+	gl::ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+	gl::Clear(gl::GL_COLOR_BUFFER_BIT);
+
+	gl::Enable(gl::GL_BLEND);
+	gl::BlendEquation(gl::GL_FUNC_ADD);
+	gl::BlendFunc(gl::GL_ONE, gl::GL_ONE_MINUS_SRC_ALPHA);
+
+	gl::UseProgram(g_program);
+	gl::ActiveTexture(gl::GL_TEXTURE0);
+	gl::BindTexture(gl::GL_TEXTURE_2D, g_pFont->GetTexture());
+
+	glutil::MatrixStack persMatrix;
+	persMatrix.PixelPerfectOrtho(g_windowSize, glm::vec2(-1.0f, 1.0f), false);
+
+	gl::UniformMatrix4fv(g_cameraToClipMatrixUnif, 1, gl::GL_FALSE, glm::value_ptr(persMatrix.Top()));
+
+	glm::vec2 currPt(50.0f, 5.0f);
+	if(!g_currString.empty())
+		DrawTextString(g_currString, currPt);
+
+	for(StringQueue::const_iterator startIt = g_strings.begin();
+		startIt != g_strings.end();
+		++startIt)
+	{
+		currPt.y += g_pFont->GetLinePixelHeight();
+
+		DrawTextString(*startIt, currPt);
+	}
+
+/*
+	gl::BindVertexArray(g_vao);
+	gl::DrawArrays(gl::GL_TRIANGLES, 0, 6 * g_numGlyphsToDraw);
+	gl::BindVertexArray(0);
+*/
+
+	gl::BindTexture(gl::GL_TEXTURE_2D, 0);
+	gl::UseProgram(0);
+
+	glfwSwapBuffers();
+}
+
+//Called whenever the window is resized. The new window size is given, in pixels.
+//This is an opportunity to call glViewport or glScissor to keep up with the change in size.
+void GLFWCALL reshape(int w, int h)
+{
+	gl::Viewport(0, 0, (GLsizei) w, (GLsizei) h);
+
+	g_windowSize.x = w;
+	g_windowSize.y = h;
+}
+
+int GLFWCALL close_cb()
+{
+	delete g_pFont;
+	g_pFont = NULL;
+
+	delete g_pVertFmt;
+	g_pVertFmt = NULL;
+
+	delete g_pStreamBuf;
+	g_pStreamBuf = NULL;
+
+	return gl::GL_TRUE;
+}
+
+void GLFWCALL CharFunc(int unicodepoint, int action)
+{
+	if(action == GLFW_RELEASE)
+		return;
+
+	if(unicodepoint < 128)
+		g_currString.push_back(static_cast<char>(unicodepoint));
+}
+
+void GLFWCALL KeyFunc(int key, int action)
+{
+	if(action == GLFW_PRESS)
+		return;
+
+	switch(key)
+	{
+	case GLFW_KEY_ENTER:
+	case GLFW_KEY_KP_ENTER:
+		if(!g_currString.empty())
+		{
+			g_strings.push_front(std::string());
+			std::swap(g_strings.front(), g_currString);
+			if(g_strings.size() > 10)
+				g_strings.pop_back();
+		}
+
+		std::cout << g_strings.size() << std::endl;
+		break;
+	case GLFW_KEY_BACKSPACE:
+		g_currString.erase(g_currString.size() - 1, 1);
+		break;
+	}
+}
+
+int main(int argc, char** argv)
+{
+	if(!glfwInit())
+		return -1;
+
+	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
+	glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
+	glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef DEBUG
+	glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, gl::GL_TRUE);
+#endif
+
+	if(!glfwOpenWindow(g_windowSize.x, g_windowSize.y, 8, 8, 8, 8, 24, 8, GLFW_WINDOW))
+	{
+		glfwTerminate();
+		return -1;
+	}
+
+	GLFWvidmode desktopMode;
+	glfwGetDesktopMode(&desktopMode);
+
+	glm::ivec2 desktopSize(desktopMode.Width, desktopMode.Height);
+	glm::ivec2 wndPos = glutil::CalcWindowPosition(g_windowSize, desktopSize,
+		glutil::WH_CENTER, glutil::WV_CENTER);
+
+	glfwSetWindowPos(wndPos.x, wndPos.y);
+
+	if(glload::LoadFunctions() == glload::LS_LOAD_FAILED)
+	{
+		glfwTerminate();
+		return -1;
+	}
+
+	glfwSetWindowTitle("GLFW Demo");
+
+	glutil::RegisterDebugOutput(glutil::STD_OUT);
+
+	init();
+
+	glfwSetWindowSizeCallback(reshape);
+	glfwSetWindowCloseCallback(close_cb);
+	glfwSetCharCallback(CharFunc);
+	glfwSetKeyCallback(KeyFunc);
+	glfwEnable(GLFW_KEY_REPEAT);
+
+	//Main loop
+	while(true)
+	{
+		display();
+
+		if(glfwGetKey(GLFW_KEY_ESC))
+		{
+			close_cb();
+			glfwCloseWindow();
+		}
+
+		if(!glfwGetWindowParam(GLFW_OPENED))
+			break;
+
+		glfwSleep(0.010);
+	}
+
+	glfwTerminate();
+	return 0;
+}

File examples/premake4.lua

 			files {"*.hpp"}
 			files {"*.h"}
 
-			UseLibs {"glload", "glimage", "glutil",
+			UseLibs {"glload", "glimage", "glutil", "glmesh",
 				"glm", "freeglut", "glfw"}
 			
 			configuration "windows"

File glimg/include/glimg/ImageCreator.h

 		\brief Creates an ImageCreator factory for making ImageSet objects.
 
 		This constructor will initialize all pixel data to 0. All memory allocation is done by the constructor;
-		this ensures that there will be data for images that was asked for even if the user does not specify them.
+		this ensures that there will be data for images that were asked for even if the user does not specify them.
 
 		\param format The ImageFormat for the ImageSet to be created.
 		\param dimensions The dimensionality of the base layer of the image.
 		faces are ordered as defined by the ARB_texture_cube_map_array extension.
 
 		If \a faceCount was 1, then there will only be one face instead of the 6. If \a arrayCount was 1
-		then there will only be one set of faces. And if they were both 1, then there is only one image.
+		then there will only be one set of faces. And if they were both 1, then there is only one image per mipmap level.
 
 		\param pixelData The pixel data for the mipmap. It is expected to be formatted exactly as specified
 		by the ImageFormat given to this ImageCreator at creation time. It must contain all of the pixel data
 		void SetFullMipmapLevel(const void *pixelData, bool isTopLeft, int mipmapLevel);
 
 		/**
-		\brief Creates an ImageSet from the stored data. The ImageCreator object is now dead.
+		\brief Creates an ImageSet from the stored data. After the completion of this function, this ImageCreator object is now dead.
 
 		Do not use the ImageCreator object after calling this. Deleting it is fine, but the data
 		has been \em transferred to the ImageSet, and no longer resides in the ImageCreator. Any attempt

File glimg/include/glimg/TextureGenerator.h

 	\param pImage The image that would be uploaded in a CreateTexture call.
 	\param forceConvertBits A bitfield containing values from ForcedConvertFlags.
 
-	\return The texture type for a texture that would be created with CreateTexture.
+	\return A GLenum for the texture type for a texture that would be created by CreateTexture.
 	**/
-	GLenum GetTextureType(const ImageSet *pImage, unsigned int forceConvertBits);
+	unsigned int GetTextureType(const ImageSet *pImage, unsigned int forceConvertBits);
 
 	/**
 	\brief Creates a texture object from the given ImageSet, with flags.

File glimg/source/TextureGenerator.cpp

 		}
 	}
 
-	GLenum GetTextureType( const ImageSet *pImage, unsigned int forceConvertBits )
+	unsigned int GetTextureType( const ImageSet *pImage, unsigned int forceConvertBits )
 	{
 		Dimensions dims = pImage->GetDimensions();
 
 			return gl::GL_TEXTURE_3D;
 		}
 
-		return -1;
+		return 0xFFFFFFFF;
 	}
 
 	unsigned int CreateTexture( const ImageSet *pImage, unsigned int forceConvertBits )

File glload/codegen/How it works.txt

 # Commit these into the "glspec" branch. Include the changelist of the data from gl-xml-spec.
 # Update the "latest-spec" tag to point to this newest commit.
 # Merge the "glspec" head with the "default" branch.
+# If the .spec files include a new OpenGL version:
+## In codegen/MakeAllFiles.lua, add lines to the `glOutputs` function to handle the new OpenGL version.
+## In codegen/data/coreExtList.lua, add a new table to contain the core ARB extensions for the new version. Then add an entry into the `masterTable` table to reference it. Make sure to take the `GL_` prefixes out.
+## In codegen/data/listOfCoreVersions.lua, add a new core version.
+## Modify `gl_all.h` and `gl_all.hpp` to include the most recent compatibility header.
+## If the new version removed (not just deprecated) functionality:
+### In codegen/MakeAllFiles, add the version to the list `removalVersions`.
 # In the glload/codegen directory, run 'lua MakeAllFiles.lua'
 # Verify that the tests and examples work.
+# Add new files from `glload/include/glload` to Mercurial.
 # Check this into the "default" branch.
 
-Any .spec file bugs that we need to fix should be fixed in gl-xml-spec project. That is where the .spec files are maintained.
-
-If the spec files include a new OpenGL version, do the following steps ''before'' running the code generation process.
-
-# In codegen/MakeAllFiles.lua, add lines to the `glOutputs` function to handle the new OpenGL version.
-# In codegen/data/coreExtList.lua, add a new table to contain the core ARB extensions for the new version. Then add an entry into the `masterTable` table to reference it. Make sure to take the `GL_` prefixes out.
-# In codegen/data/listOfCoreVersions.lua, add a new core version.
-# If the new version removed (not just deprecated) functionality:
-## In codegen/MakeAllFiles, add the version to the list `removalVersions`.
+Any .spec file bugs that we need to fix should be fixed in gl-xml-spec project. That is where the .spec files are maintained.

File glload/codegen/MakeAllFiles.lua

 	{"gl_4_1_comp", "4.1", false},
 	{"gl_4_2", "4.2", true},
 	{"gl_4_2_comp", "4.2", false},
+	{"gl_4_3", "4.3", true},
+	{"gl_4_3_comp", "4.3", false},
 };
 
 local glTruncPreceedData = {}

File glload/codegen/data/coreExtList.lua

 	"ARB_texture_storage",
 };
 
+local coreExts4_3 = {
+	"KHR_debug",
+	"ARB_arrays_of_arrays",
+	"ARB_clear_buffer_object",
+	"ARB_compute_shader",
+	"ARB_copy_image",
+	"ARB_debug_group",
+	"ARB_debug_label",
+	"ARB_debug_output2",
+	"ARB_ES3_compatibility",
+	"ARB_explicit_uniform_location",
+	"ARB_fragment_layer_viewport",
+	"ARB_framebuffer_no_attachments",
+	"ARB_internalformat_query2",
+	"ARB_invalidate_subdata",
+	"ARB_multi_draw_indirect",
+	"ARB_program_interface_query",
+	"ARB_shader_image_size",
+	"ARB_shader_storage_buffer_object",
+	"ARB_stencil_texturing",
+	"ARB_texture_buffer_range",
+	"ARB_texture_query_levels",
+	"ARB_texture_storage_multisample",
+	"ARB_texture_view",
+	"ARB_vertex_attrib_binding",
+};
+
 local masterTable = {
 	["3.0"] = coreExts3_0,
 	["3.1"] = coreExts3_1,
 	["4.0"] = coreExts4_0,
 	["4.1"] = coreExts4_1,
 	["4.2"] = coreExts4_2,
+	["4.3"] = coreExts4_3,
 };
 
 

File glload/codegen/data/listOfCoreVersions.lua

 	"4.0",
 	"4.1",
 	"4.2",
+	"4.3",
 }